text:
@()(implicit lang: Lang,
        token: uk.gov.dvla.vehicles.presentation.common.filters.CsrfPreventionAction.CsrfPreventionToken,
        config: utils.helpers.Config,
        dateService: uk.gov.dvla.vehicles.presentation.common.services.DateService)

@import controllers.routes.PaymentPreventBack
@import views.html.vrm_retention.main
@import views.vrm_retention.PaymentPreventBack.ReturnToSuccessId

@main(
    title = Messages("payment-prevent-back-title")
) {

@Messages("payment-prevent-back-title")

@Messages("payment-prevent-back-text")

        @Messages("payment-prevent-back-return-to-success")

}


text:
import sys
from PyQt4.QtGui import *

# Create an PyQT4 application object.
app = QApplication(sys.argv)

# The QWidget widget is the base class of all user interface objects in PyQt4.
window = QMainWindow()

# Set window size.
window.resize(320, 240)

# Set window title
window.setWindowTitle("Hello World!")

# ==========================================================
# Create textbox
textbox = QLineEdit(window)
textbox.move(20, 20)
textbox.resize(280,40)

# ==========================================================

# Show window
window.show()

sys.exit(app.exec_())

redpajama_set_name: RedPajamaGithub


text:
package com.huawei.openview.devops.domain.action.pod;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * Created by panguobin on 3/10/17.
 */
@Getter
@Setter
@ToString
@JsonIgnoreProperties(ignoreUnknown = true)
public class ItemStatusCondition {
    private boolean status;
    private String reason;
}


text:
namespace Elders.Hystrix.NET
{
    public class HystrixCollapserSetter
    {
        private readonly IHystrixCollapserKey collapserKey;

        public IHystrixCollapserKey CollapserKey { get { return this.collapserKey; } }
        public HystrixCollapserScope Scope { get; private set; }
        public HystrixCollapserPropertiesSetter PropertiesSetter { get; private set; }

        private HystrixCollapserSetter(IHystrixCollapserKey collapserKey)
        {
            this.collapserKey = collapserKey;
        }

        public static HystrixCollapserSetter WithCollapserKey(IHystrixCollapserKey collapserKey)
        {
            return new HystrixCollapserSetter(collapserKey);
        }
        public HystrixCollapserSetter AndScope(HystrixCollapserScope scope)
        {
            Scope = scope;
            return this;
        }
        public HystrixCollapserSetter AndCollapserPropertiesDefaults(HystrixCollapserPropertiesSetter propertiesSetter)
        {
            PropertiesSetter = propertiesSetter;
            return this;
        }
    }
}


text:
package de.tudarmstadt.ukp.clarin.webanno.api.annotation.feature.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties("annotation.feature-support.string")
public class PrimitiveUimaFeatureSupportProperties
{
    /**
     * If the tagset is larger than the threshold, an auto-complete field is used instead of a
     * standard combobox.
     */
    private int autoCompleteThreshold = 75;

    /**
     * When an auto-complete field is used, this determines the maximum number of items shown in the
     * dropdown menu.
     */
    private int autoCompleteMaxResults = 100;

    public int getAutoCompleteThreshold()
    {
        return autoCompleteThreshold;
    }

    public void setAutoCompleteThreshold(int aAutoCompleteThreshold)
    {
        autoCompleteThreshold = aAutoCompleteThreshold;
    }

    public int getAutoCompleteMaxResults()
    {
        return autoCompleteMaxResults;
    }

    public void setAutoCompleteMaxResults(int aAutoCompleteMaxResults)
    {
        autoCompleteMaxResults = aAutoCompleteMaxResults;
    }
}


text:
<!doctype html>

<meta charset="utf-8">
<title>oshchip.org</title>
<meta name="description" content="OSHChip home on the WWW">
<meta name="keywords" content="Jekyll, theme, responsive, blog, template">

<meta name="twitter:title" content="oshchip.org">
<meta name="twitter:description" content="OSHChip home on the WWW">
<meta name="twitter:site" content="@PhilipFreidin">
<meta name="twitter:creator" content="@PhilipFreidin">

<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="http://localhost:4000/images/header.jpg">

<meta property="og:locale" content="en_US">
<meta property="og:type" content="article">
<meta property="og:title" content="oshchip.org">
<meta property="og:description" content="OSHChip home on the WWW">
<meta property="og:url" content="http://localhost:4000/">
<meta property="og:site_name" content="oshchip.org">

<link rel="canonical" href="http://localhost:4000/">
<link href="http://localhost:4000/feed.xml" type="application/atom+xml" rel="alternate" title="oshchip.org Feed">

<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1.0">

<link rel="stylesheet" href="http://localhost:4000/assets/css/main.css">

<meta http-equiv="cleartype" content="on">

<link href='//fonts.googleapis.com/css?family=PT+Sans+Narrow:400,700%7CPT+Serif:400,700,400italic' rel='stylesheet' type='text/css'>

<link rel="shortcut icon" href="http://localhost:4000/favicon.ico">

<link rel="shortcut icon" href="http://localhost:4000/favicon.png">

<link rel="apple-touch-icon-precomposed" href="http://localhost:4000/images/apple-touch-icon-precomposed.png">

<link rel="apple-touch-icon-precomposed" sizes="72x72" href="http://localhost:4000/images/apple-touch-icon-72x72-precomposed.png">

<link rel="apple-touch-icon-precomposed" sizes="114x114" href="http://localhost:4000/images/apple-touch-icon-114x114-precomposed.png">

<link rel="apple-touch-icon-precomposed" sizes="144x144" href="http://localhost:4000/images/apple-touch-icon-144x144-precomposed.png">
<link rel="canonical" href="http://oshchip.org/" />

		oshchip.org

Products

Docs

FAQ

About

              <form style="display: inline;" onsubmit="my_search_google()" >
                <input style="width: 200px;"
                       type="text" placeholder="Search"
                       id="my-google-search"/>
              </form>

OSHChip

32 bit Cortex-M0 with 256 KB Flash, 32KB RAM, and Bluetooth LE radio

 Email
 Twitter

 Github

OSHChip   One product, Two views

OSHChip as a general purpose processor board

View 1:  OSHChip_V1.0 is a unique combination of

ARM Cortex-M0 32 bit processor running at 16 MHz

2.4 GHz Bluetooth Low Energy radio

Broad range of built-in Peripheral functions

256 KBytes of Flash memory for program and data

32 KBytes of SRAM

Minature packaging, compatible with bread board construction

Support for in-system debugging including breakpoints

The most striking thing you see is that it is the size of a 16 pin
DIP, and unlike other processor boards, it is designed from the start
to be compatible with the white breadboards that are commonly used by
electronic hobbyists, robotics projects, and oh so many hackaday
projects. The pins are directly designed to work with these bread
boards, and unlike the usual pin strips found on other processor
boards, they plug in easily to the bread board, and don't damage it.
Unlike other processor boards that are far larger, OSHChip can be
plugged into the middle two rows of a bread board, and it doesn't
cover the connected holes that you will be connecting to.

OSHChip_V1.0 is an Open Source Hardware design. It's right there
in the name. You can find all the schematics, bill of materials,
printed circuit board design files and the resultant Gerber files
here: https://github.com/OSHChip/OSHChip_V1.0_Docs

OSHChip as a platform for designing custom chips

View 2:  You get to be a chip designer.

Imagine you wanted to design a chip. Nothing too fancy, but let's
including some general purpose digital inputs and outputs, some analog
inputs, some counters, timers, or PWM, maybe able to talk to another
chip over SPI or I2C, some storage for calibration constants, maybe a
linearization table, and an on-board processor that can be programmed
in C. While we are dreaming, lets also include a low power mode that
only draws a microamp or two, can communicate with a UART to a
terminal program on your computer, and lets add in a 2.4 GHz radio
that can operate with the Bluetooth Low Energy protocol to smart
phones, like Android phones and iDevices.

© 2015 OSHChip. Powered by Jekyll using the Minimal Mistakes theme.


text:
#include <dlfcn.h>
#include <errno.h>
#include <stdlib.h>

#include <TargetConditionals.h>

#if !TARGET_OS_IPHONE
# include <CoreFoundation/CoreFoundation.h>
# include <ApplicationServices/ApplicationServices.h>
#endif

static int uv__pthread_setname_np(const char* name) {
  int (*dynamic_pthread_setname_np)(const char* name);
  char namebuf[64];  /* MAXTHREADNAMESIZE */
  int err;

  /* pthread_setname_np() first appeared in OS X 10.6 and iOS 3.2. */
  dynamic_pthread_setname_np = dlsym(RTLD_DEFAULT, "pthread_setname_np");
  if (dynamic_pthread_setname_np == NULL)
    return -ENOSYS;

  strncpy(namebuf, name, sizeof(namebuf) - 1);
  namebuf[sizeof(namebuf) - 1] = '\0';

  err = dynamic_pthread_setname_np(namebuf);
  if (err)
    return -err;

  return 0;
}

int uv__set_process_title(const char* title) {
#if TARGET_OS_IPHONE
  return uv__pthread_setname_np(title);
#else
  CFStringRef (*pCFStringCreateWithCString)(CFAllocatorRef,
                                            const char*,
                                            CFStringEncoding);
  CFBundleRef (*pCFBundleGetBundleWithIdentifier)(CFStringRef);
  void *(*pCFBundleGetDataPointerForName)(CFBundleRef, CFStringRef);
  void *(*pCFBundleGetFunctionPointerForName)(CFBundleRef, CFStringRef);
  OSErr (*pGetCurrentProcess)(ProcessSerialNumber*);
  CFTypeRef (*pLSGetCurrentApplicationASN)(void);
  OSStatus (*pLSSetApplicationInformationItem)(int,
                                               CFTypeRef,
                                               CFStringRef,
                                               CFStringRef,
                                               CFDictionaryRef*);
  void* application_services_handle;
  void* core_foundation_handle;
  CFBundleRef launch_services_bundle;
  CFStringRef* display_name_key;
  ProcessSerialNumber psn;
  CFTypeRef asn;
  int err;

  err = -ENOENT;
  application_services_handle = dlopen("/System/Library/Frameworks/"
                                       "ApplicationServices.framework/"
                                       "Versions/A/ApplicationServices",
                                       RTLD_LAZY | RTLD_LOCAL);
  core_foundation_handle = dlopen("/System/Library/Frameworks/"
                                  "CoreFoundation.framework/"
                                  "Versions/A/CoreFoundation",
                                  RTLD_LAZY | RTLD_LOCAL);

  if (application_services_handle == NULL || core_foundation_handle == NULL)
    goto out;

  pGetCurrentProcess =
      dlsym(application_services_handle, "GetCurrentProcess");
  pCFStringCreateWithCString =
      dlsym(core_foundation_handle, "CFStringCreateWithCString");
  pCFBundleGetBundleWithIdentifier =
      dlsym(core_foundation_handle, "CFBundleGetBundleWithIdentifier");
  pCFBundleGetDataPointerForName =
      dlsym(core_foundation_handle, "CFBundleGetDataPointerForName");
  pCFBundleGetFunctionPointerForName =
      dlsym(core_foundation_handle, "CFBundleGetFunctionPointerForName");

  if (pGetCurrentProcess == NULL ||
      pCFStringCreateWithCString == NULL ||
      pCFBundleGetBundleWithIdentifier == NULL ||
      pCFBundleGetDataPointerForName == NULL ||
      pCFBundleGetFunctionPointerForName == NULL) {
    goto out;
  }

#define S(s) pCFStringCreateWithCString(NULL, (s), kCFStringEncodingUTF8)

  launch_services_bundle =
      pCFBundleGetBundleWithIdentifier(S("com.apple.LaunchServices"));

  if (launch_services_bundle == NULL)
    goto out;

  pLSGetCurrentApplicationASN =
      pCFBundleGetFunctionPointerForName(launch_services_bundle,
                                         S("_LSGetCurrentApplicationASN"));

  if (pLSGetCurrentApplicationASN == NULL)
    goto out;

  pLSSetApplicationInformationItem =
      pCFBundleGetFunctionPointerForName(launch_services_bundle,
                                         S("_LSSetApplicationInformationItem"));

  if (pLSSetApplicationInformationItem == NULL)
    goto out;

  display_name_key = pCFBundleGetDataPointerForName(launch_services_bundle,
                                                    S("_kLSDisplayNameKey"));

  if (display_name_key == NULL || *display_name_key == NULL)
    goto out;

  /* Force the process manager to initialize. */
  pGetCurrentProcess(&psn);

  asn = pLSGetCurrentApplicationASN();

  err = -EINVAL;
  if (pLSSetApplicationInformationItem(-2,  /* Magic value. */
                                       asn,
                                       *display_name_key,
                                       S(title),
                                       NULL) != noErr) {
    goto out;
  }

  uv__pthread_setname_np(title);  /* Don't care if it fails. */
  err = 0;

out:
  if (core_foundation_handle != NULL)
    dlclose(core_foundation_handle);

  if (application_services_handle != NULL)
    dlclose(application_services_handle);

  return err;
#endif  /* !TARGET_OS_IPHONE */
}


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.atomique.ksar.Esar;

import javax.swing.tree.DefaultMutableTreeNode;
import net.atomique.ksar.AllGraph;
import net.atomique.ksar.GraphDescription;
import net.atomique.ksar.kSar;
import net.atomique.ksar.kSarConfig;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.CombinedDomainXYPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.StandardXYItemRenderer;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.data.time.Second;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.xy.XYDataset;

/**
 *
 * @author alex
 */
public class iface1Sar extends AllGraph {

    public iface1Sar(kSar hissar, String s1) {
        super(hissar);
        Title = new String("Interface traffic");
        this.ifName = s1;
        t_rxpck = new TimeSeries("ipacket/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " ipacket/s", t_rxpck);
        t_txpck = new TimeSeries("opacket/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " opacket/s", t_txpck);
        t_rxbyt = new TimeSeries("ibits/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " ibits/s", t_rxbyt);
        t_txbyt = new TimeSeries("obits/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " obits/s", t_txbyt);
        t_ierr = new TimeSeries("ierror/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " ierror/s", t_ierr);
        t_oerr = new TimeSeries("oerror/s", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " oerror/s", t_oerr);
        t_util = new TimeSeries("%util", org.jfree.data.time.Second.class);
        mysar.dispo.put("IF " + s1 + " %util", t_util);
    }

    public void add(Second now, Float val1, Float val2, Float val3, Float val4, Float val5, Float val6, Float val7) {
        this.t_rxpck.add(now, val1, do_notify());
        this.t_txpck.add(now, val2, do_notify());
        this.t_rxbyt.add(now, val3, do_notify());
        this.t_txbyt.add(now, val4, do_notify());
        this.t_ierr.add(now, val5, do_notify());
        this.t_oerr.add(now, val6, do_notify());
        this.t_util.add(now, val7, do_notify());
        number_of_sample++;
    }

    public void setifOpt(String s) {
        this.ifOpt = s;
    }

    public XYDataset createpck() {
        TimeSeriesCollection graphcollection = new TimeSeriesCollection();
        graphcollection.addSeries(this.t_rxpck);
        graphcollection.addSeries(this.t_txpck);
        return graphcollection;
    }

    public XYDataset createbyt() {
        TimeSeriesCollection graphcollection = new TimeSeriesCollection();
        graphcollection.addSeries(this.t_rxbyt);
        graphcollection.addSeries(this.t_txbyt);
        return graphcollection;
    }

    public XYDataset createerr() {
        TimeSeriesCollection graphcollection = new TimeSeriesCollection();
        graphcollection.addSeries(this.t_ierr);
        graphcollection.addSeries(this.t_oerr);
        return graphcollection;
    }

    public XYDataset createutil() {
        TimeSeriesCollection graphcollection = new TimeSeriesCollection();
        graphcollection.addSeries(this.t_util);
        return graphcollection;
    }

    public String getcheckBoxTitle() {
        return "Interface " + this.ifName;
    }

    public void addtotree(DefaultMutableTreeNode myroot) {
        mynode = new DefaultMutableTreeNode(new GraphDescription(this, "ESARIFACE1", this.Title, null));
        mysar.add2tree(myroot, mynode);
    }

    public String getGraphTitle() {
        return (this.Title + " " + this.ifName + " for " + mysar.hostName);
    }

    public JFreeChart makegraph(Second g_start, Second g_end) {
        // tps
        XYDataset xydataset1 = this.createpck();
        XYItemRenderer minichart1 = new StandardXYItemRenderer();
        minichart1.setBaseStroke(kSarConfig.DEFAULT_STROKE);
        minichart1.setSeriesPaint(0, kSarConfig.color1);
        minichart1.setSeriesPaint(1, kSarConfig.color2);
        XYPlot subplot1 = new XYPlot(xydataset1, null, new NumberAxis("ipacket/opacket /s"), minichart1);
        // rws
        XYDataset bytset = this.createbyt();
        XYItemRenderer minichart2 = new StandardXYItemRenderer();
        minichart2.setSeriesPaint(0, kSarConfig.color3);
        minichart2.setSeriesPaint(1, kSarConfig.color4);
        minichart2.setBaseStroke(kSarConfig.DEFAULT_STROKE);
        XYPlot subplot2 = new XYPlot(bytset, null, new NumberAxis("ibits/obits /s"), minichart2);
        //
        XYDataset cmpset = this.createerr();
        XYItemRenderer minichart3 = new StandardXYItemRenderer();
        minichart3.setSeriesPaint(0, kSarConfig.color5);
        minichart3.setSeriesPaint(1, kSarConfig.color6);
        minichart3.setBaseStroke(kSarConfig.DEFAULT_STROKE);
        XYPlot subplot3 = new XYPlot(cmpset, null, new NumberAxis("ierr/oerr /s"), minichart3);
        //
        XYDataset mcstset = this.createutil();
        XYItemRenderer minichart4 = new StandardXYItemRenderer();
        minichart4.setSeriesPaint(0, kSarConfig.color7);
        minichart4.setBaseStroke(kSarConfig.DEFAULT_STROKE);
        XYPlot subplot4 = new XYPlot(mcstset, null, new NumberAxis("%util"), minichart4);
        //
        CombinedDomainXYPlot plot = new CombinedDomainXYPlot(new DateAxis(""));
        plot.add(subplot1, 1);
        plot.add(subplot2, 1);
        plot.add(subplot3, 1);
        plot.add(subplot4, 1);
        plot.setOrientation(PlotOrientation.VERTICAL);
        // the graph
        JFreeChart mychart = new JFreeChart(this.getGraphTitle(), kSarConfig.DEFAULT_FONT, plot, true);
        if (g_start != null) {
            DateAxis dateaxis1 = (DateAxis) mychart.getXYPlot().getDomainAxis();
            dateaxis1.setRange(g_start.getStart(), g_end.getEnd());
        }
        if (setbackgroundimage(mychart) == 1) {
            subplot1.setBackgroundPaint(null);
            subplot2.setBackgroundPaint(null);
            subplot3.setBackgroundPaint(null);
            subplot4.setBackgroundPaint(null);
        }
        return mychart;
    }
    private TimeSeries t_rxpck;
    private TimeSeries t_txpck;
    private TimeSeries t_rxbyt;
    private TimeSeries t_txbyt;
    private TimeSeries t_ierr;
    private TimeSeries t_oerr;
    private TimeSeries t_util;
    private String ifName;
    private String ifOpt = new String("");
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Bull. Torrey bot. Club 34: 478 (1907)

#### Original name
Polyporus endotheius Berk.

### Remarks
null


text:
'use strict';

describe('Controller: FiltersCtrl', function()
{

    // load the controller's module
    beforeEach(module('pitchfxApp'));

    var FiltersCtrl,
        scope,
        $httpBackend;

    // Initialize the controller and a mock scope
    beforeEach(inject(function(_$httpBackend_, $controller, $rootScope)
    {
        $httpBackend = _$httpBackend_;
        scope = $rootScope.$new();
        FiltersCtrl = $controller('FiltersCtrl',
        {
            $scope: scope
        });
    }));

    it('Test the initial filter', function()
    {
        var filters = scope.filters;
        expect(filters).toBeTruthy();

        /* default starting date should be 1st of some year */
        expect(moment(filters.date.start).dayOfYear()).toBe(1);

        /* default end date should be today */
        expect(filters.date.end).toBe(moment().format('YYYY-MM-DD'));

        /* only look at regular season games by default */
        expect(filters.gameType.R).toBe(true);
        expect(Object.keys(filters.gameType).length).toBe(1);
    });
});


text:
class coEntityType : public coCustomTypeData
{
public:
	void AddComponent(const coType& type);
	template <class T>
	void AddComponent() { AddComponent(*T::GetStaticType()); }
	const coArray<const coType*>& GetComponentTypes() const { return componentTypes; }
	coInt GetComponentIndexByTypeUID(coUint32 uid) const;

private:
	coDynamicArray<const coType*> componentTypes;
};

#define coDECLARE_ENTITY(_Type_) \
	class _Type_ \
	{ \
		coDECLARE_CLASS_NO_POLYMORPHISM(_Type_);\
	}


text:
import submodule = require('../src/submodule/submodule');
import externalLib = require('externalLib');

describe("app", () => {
  it("externalLib can be called", () => {
    expect(externalLib.doSomething(submodule)).toBeUndefined();
  });

  it("submodule return value can be reached", () => {
    expect(submodule).toBe("Hello from submodule");
  });
});


text:
namespace NorthwindWindowsStore.DAL
{
    using NorthwindWindowsStore.DAL.Model;

    public class ShipperRepository : BaseRepository<Shipper>
    {
        public ShipperRepository(string path)
            : base(path)
        {
        }
    }
}


text:
objstor
=====

OpenStack Swift Object Storage front end written in bash with minimal dependencies and simplicity in mind.

Dependencies
=====

* curl
* file
* grep
* awk
* md5sum
* dd
* tr

Usage
=====

```
Usage: objstor.sh [options] <action> [path] [path2...]
Options:
   -u Username
   -k Key
   -a Auth URL
   -o Overwrite existing file/object

Actions:
   stats - Get information about your Object Storage account.

   save - Save authentication details specified with -u -k and -a to ~/.objstor
     so they do not need to be specified in later calls of the program.
     The ~/.objstor file is a simple bash file that is sourced.

   ls - List the contents of the container specified. This will return the
     containers if none specified. If an object is specified, it's details
     are retrieved.

   get - Download the object specified to the current directory. If the
     filename already exists in the current directory, an error is
     returned. Specifying -o will overwrite the existing file.

   put - Upload file to object storage. The container is specified as the
     first argument and the list of files following that. If an object
     already exists, it will not be overwritten unless -o option is used.

   del - Delete file(s) in object storage. The path must include the container
     first. Multiple files may be specified for deletion.

Other Notes:
   Authentication information specified with the -u -k and -a options takes precedence over the configured ~/.objstor credentials.

Examples:
   Save:
    objstor.sh save -u myusername -k mykey -a 'https://swift.server.url/auth'

   List:
    objstor.sh ls
    objstor.sh ls mycontainer
    objstor.sh ls mycontainer/myobject

   Get:
    objstor.sh get mycontainer/myobject

   Put:
    objstor.sh put mycontainer mylocalfile myotherlocalfile

   Delete:
    objstor.sh del mycontainer/myobject mycontainer/myotherobject

Return Codes:
   0 - Success!
   1 - Undefined error
   2 - Missing dependency
   3 - Incorrect arguments passed
   4 - Missing credentials
   5 - Failed authentication
```


text:
class YoYo<T> {
    private YoYoYo myYoYoYo;

    void <caret>foo () {
        myYoYoYo.getClass();
    }
}

class YoYoYo extends YoYo {}


text:
package org.drools.workbench.screens.scenariosimulation.client.collectioneditor.editingbox;

import java.util.Map;

import com.google.gwt.dom.client.LIElement;
import com.google.gwt.dom.client.UListElement;

public interface KeyValueEditingBox extends EditingBox<KeyValueEditingBox.Presenter> {

    interface Presenter extends EditingBox.Presenter {

        /**
         * @param key The key representing the property, i.e Classname#propertyname (e.g Author#books)
         * @param keyPropertyMap
         * @param valuePropertyMap
         */
        LIElement getEditingBox(String key, Map<String, String> keyPropertyMap, Map<String, String> valuePropertyMap);
    }

    LIElement getKeyValueContainer();

    UListElement getKeyContainer();

    UListElement getValueContainer();
}


text:
package org.pacesys.kbop.internal;

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * A future which waits until the Pooled Object is available or times out
 *
 * @param <T> the generic type
 * @author Jeremy Unruh
 */
public abstract class PoolWaitFuture<T> implements Future<T> {

  private final Lock lock;
  private final Condition condition;
  private volatile boolean cancelled;
  private volatile boolean completed;
  private T result;

  /**
   * Instantiates a new pool wait future.
   *
   * @param lock the lock
   */
  public PoolWaitFuture(Lock lock) {
	this.lock = lock;
	this.condition = lock.newCondition();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public boolean cancel(boolean mayInterruptIfRunning) {
	this.lock.lock();
	try {
	  if (this.completed) {
		return false;
	  }
	  this.completed = true;
	  this.cancelled = true;
	  this.condition.signalAll();
	  return true;
	} finally {
	  this.lock.unlock();
	}
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public boolean isCancelled() {
	return this.cancelled;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public boolean isDone() {
	return this.completed;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public T get() throws InterruptedException, ExecutionException {
	try {
	  return get(0, TimeUnit.MILLISECONDS);
	} catch (TimeoutException ex) {
	  throw new ExecutionException(ex);
	}
  }

  /**
   * Attempts to borrow/get the Pool Object from the Pool
   *
   * @param timeout the timeout
   * @param unit the unit
   * @return the entry
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws InterruptedException the interrupted exception
   * @throws TimeoutException the timeout exception
   */
  protected abstract T getPoolObject(long timeout, TimeUnit unit) throws IOException, InterruptedException, TimeoutException;

  /**
   * {@inheritDoc}
   */
  @Override
  public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
	this.lock.lock();
	try {
	  if (this.completed) {
		return this.result;
	  }
	  this.result = getPoolObject(timeout, unit);
	  this.completed = true;
	  return result;
	} catch (IOException ex) {
	  this.completed = true;
	  this.result = null;
	  throw new ExecutionException(ex);
	} finally {
	  this.lock.unlock();
	}
  }

  /**
   * Waits/Blocks until the specified deadline or condition
   *
   * @param deadline the deadline
   * @return true, if successful
   * @throws InterruptedException the interrupted exception
   */
  public boolean await(final Date deadline) throws InterruptedException {
	this.lock.lock();
	try {
	  if (this.cancelled) {
		throw new InterruptedException("Operation interrupted");
	  }
	  boolean success = false;
	  if (deadline != null) {
		success = this.condition.awaitUntil(deadline);
	  } else {
		this.condition.await();
		success = true;
	  }
	  if (this.cancelled) {
		throw new InterruptedException("Operation interrupted");
	  }
	  return success;
	} finally {
	  this.lock.unlock();
	}

  }

  /**
   * Wakes up the current listener
   */
  public void wakeup() {
	this.lock.lock();
	try {
	  this.condition.signalAll();
	} finally {
	  this.lock.unlock();
	}
  }

}


text:
<?php
require_once('bank_proses.php');
?>

<!DOCTYPE html>

<meta charset="UTF-8">

<link type="text/css" href="../../../config/css/style.css" rel="stylesheet">
<link type="text/css" href="../../../plugin/css/zebra/default.css" rel="stylesheet">
<link type="text/css" href="../../../plugin/window/themes/default.css" rel="stylesheet">
<link type="text/css" href="../../../plugin/window/themes/mac_os_x.css" rel="stylesheet">

<form name="form" id="form" method="post">

	KODE
	<input type="text" name="kode_bank" id="kode_bank" size="3" value="<?php echo $kode_bank; ?>">

	BANK
	<input type="text" name="nama_bank" id="nama_bank" size="50" value="<?php echo $nama_bank; ?>">

	CABANG
	<input type="text" name="cb_bank" id="cb_bank" size="50" value="<?php echo $cb_bank; ?>">

	ALAMAT
	<textarea name="alamat" id="alamat" cols="52" rows="3"><?php echo $alamat; ?></textarea>

		<input type="submit" id="save" value=" <?php echo $act; ?> (Alt+S) ">
		<input type="reset" id="reset" value=" Reset (Alt+R) ">
		<input type="button" id="close" value=" Tutup (Esc) ">

<input type="hidden" name="id" id="id" value="<?php echo $id; ?>">
<input type="hidden" name="act" id="act" value="<?php echo $act; ?>">
</form>

<?php close($conn); ?>


text:
using System;
using System.IO;

namespace DiscUtils.Streams
{
    public abstract class DataWriter
    {
        private const int _bufferSize = sizeof(UInt64);

        protected readonly Stream _stream;

        protected byte[] _buffer;

        public DataWriter(Stream stream)
        {
            _stream = stream;
        }

        public abstract void Write(ushort value);

        public abstract void Write(int value);

        public abstract void Write(uint value);

        public abstract void Write(long value);

        public abstract void Write(ulong value);

        public virtual void WriteBytes(byte[] value, int offset, int count)
        {
            _stream.Write(value, offset, count);
        }

        public virtual void WriteBytes(byte[] value)
        {
            _stream.Write(value, 0, value.Length);
        }

        public virtual void Flush()
        {
            _stream.Flush();
        }

        protected void EnsureBuffer()
        {
            if (_buffer == null)
            {
                _buffer = new byte[_bufferSize];
            }
        }

        protected void FlushBuffer(int count)
        {
            _stream.Write(_buffer, 0, count);
        }
    }
}


text:
/* Projects carousel */

$('.carousel').carousel();

/* Slider 1 - Parallax slider*/

$(function() {
	$('#da-slider').cslider({
		autoplay	: true,
		interval : 9000
	});

});
/* prettyPhoto Gallery */

jQuery(".prettyphoto").prettyPhoto({
   overlay_gallery: false, social_tools: false
});

/* Isotope */

// cache container
var $container = $('#portfolio');
// initialize isotope
$container.isotope({
  // options...
});

// filter items when filter link is clicked
$('#filters a').click(function(){
  var selector = $(this).attr('data-filter');
  $container.isotope({ filter: selector });
  return false;
});

/* Flex slider */

  $(window).load(function() {
    $('.flexslider').flexslider({
      easing: "easeInOutSine",
      directionNav: false,
      animationSpeed: 1500,
      slideshowSpeed: 5000
    });
  });

/* Image block effects */

$(function() {
      $('ul.hover-block li').hover(function(){
        $(this).find('.hover-content').animate({top:'-3px'},{queue:false,duration:500});
      }, function(){
        $(this).find('.hover-content').animate({top:'155px'},{queue:false,duration:500});
      });
});

/* Slide up & Down */

$(".dis-nav a").click(function(e){
	e.preventDefault();
	var myClass=$(this).attr("id");
	$(".dis-content ."+myClass).toggle('slow');
});

/* Image slideshow */

$('#s1').cycle({
    fx:    'fade',
    speed:  2000,
    timeout: 300,
    pause: 1
 });

/* Support */

$("#slist a").click(function(e){
   e.preventDefault();
   $(this).next('p').toggle(200);
});


text:
// Type definitions for d3JS
// Project: http://d3js.org/
// Definitions by: TypeScript samples
// Definitions: https://github.com/borisyankov/DefinitelyTyped

module D3 {
    interface Selectors {
        /**
        * Select an element from the current document
        */
        select: {
            /**
            * Selects the first element that matches the specified selector string
            *
            * @param selector Selection String to match
            */
            (selector: string): Selection;
            /**
            * Selects the specified node
            *
            * @param element Node element to select
            */
            (element: EventTarget): Selection;
        };

        /**
        * Select multiple elements from the current document
        */
        selectAll: {
            /**
            * Selects all elements that match the specified selector
            *
            * @param selector Selection String to match
            */
            (selector: string): Selection;
            /**
            * Selects the specified array of elements
            *
            * @param elements Array of node elements to select
            */
            (elements: EventTarget[]): Selection;
        };
    }

    interface Behavior {
        /**
        * Constructs a new drag behaviour
        */
        drag: () => Drag;
        /**
        * Constructs a new zoom behaviour
        */
        zoom: () => Zoom;
    }

    interface Zoom {
        /**
        * Execute zoom method
        */
        (): any;

        /**
        * Registers a listener to receive events
        *
        * @param type Enent name to attach the listener to
        * @param listener Function to attach to event
        */
        on: (type: string, listener: (data: any, index?: number) => any) => Zoom;

        /**
        * Gets or set the current zoom scale
        */
        scale: {
            /**
            * Get the current current zoom scale
            */
            (): number;
            /**
            * Set the current current zoom scale
            *
            * @param origin Zoom scale
            */
            (scale: number): Zoom;
        };

        /**
        * Gets or set the current zoom translation vector
        */
        translate: {
            /**
            * Get the current zoom translation vector
            */
            (): number[];
            /**
            * Set the current zoom translation vector
            *
            * @param translate Tranlation vector
            */
            (translate: number[]): Zoom;
        };

        /**
        * Gets or set the allowed scale range
        */
        scaleExtent: {
            /**
            * Get the current allowed zoom range
            */
            (): number[];
            /**
            * Set the allowable zoom range
            *
            * @param extent Allowed zoom range
            */
            (extent: number[]): Zoom;
        };

        /**
        * Gets or set the X-Scale that should be adjusted when zooming
        */
        x: {
            /**
            * Get the X-Scale
            */
            (): Scale;
            /**
            * Set the X-Scale to be adjusted
            *
            * @param x The X Scale
            */
            (x: Scale): Zoom;

        };

        /**
        * Gets or set the Y-Scale that should be adjusted when zooming
        */
        y: {
            /**
            * Get the Y-Scale
            */
            (): Scale;
            /**
            * Set the Y-Scale to be adjusted
            *
            * @param y The Y Scale
            */
            (y: Scale): Zoom;
        };
    }

    interface Drag {
        /**
        * Execute drag method
        */
        (): any;

        /**
        * Registers a listener to receive events
        *
        * @param type Enent name to attach the listener to
        * @param listener Function to attach to event
        */
        on: (type: string, listener: (data: any, index?: number) => any) => Drag;

        /**
        * Gets or set the current origin accessor function
        */
        origin: {
            /**
            * Get the current origin accessor function
            */
            (): any;
            /**
            * Set the origin accessor function
            *
            * @param origin Accessor function
            */
            (origin?: any): Drag;
        };
    }

    interface Event {
        dx: number;
        dy: number;
        clientX: number;
        clientY: number;
        translate: number[];
        scale: number;
        sourceEvent: Event;
        x: number;
        y: number;
    }

    interface Base extends Selectors {
        /**
        * Create a behaviour
        */
        behavior: Behavior;
        /**
        * Access the current user event for interaction
        */
        event: Event;

        /**
        * Compare two values for sorting.
        * Returns -1 if a is less than b, or 1 if a is greater than b, or 0
        *
        * @param a First number
        * @param b Second number
        */
        ascending: (a: number, b: number) => number;
        /**
        * Compare two values for sorting.
        * Returns -1 if a is greater than b, or 1 if a is less than b, or 0
        *
        * @param a First number
        * @param b Second number
        */
        descending: (a: number, b: number) => number;
        /**
        * Find the minimum value in an array
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        min: (arr: number[], map?: (v: any) => any) => number;
        /**
        * Find the maximum value in an array
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        max: (arr: number[], map?: (v: any) => any) => number;
        /**
        * Find the minimum and maximum value in an array
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        extent: (arr: number[], map?: (v: any) => any) => number[];
        /**
        * Compute the sum of an array of numbers
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        sum: (arr: number[], map?: (v: any) => any) => number;
        /**
        * Compute the arithmetic mean of an array of numbers
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        mean: (arr: number[], map?: (v: any) => any) => number;
        /**
        * Compute the median of an array of numbers (the 0.5-quantile).
        *
        * @param arr Array to search
        * @param map Accsessor function
        */
        median: (arr: number[], map?: (v: any) => any) => number;
        /**
        * Compute a quantile for a sorted array of numbers.
        *
        * @param arr Array to search
        * @param p The quantile to return
        */
        quantile: (arr: number[], p: number) => number;
        /**
        * Locate the insertion point for x in array to maintain sorted order
        *
        * @param arr Array to search
        * @param x Value to serch for insertion point
        * @param low Minimum value of array subset
        * @param hihg Maximum value of array subset
        */
        bisect: (arr: any[], x: any, low?: number, high?: number) => number;
        /**
        * Locate the insertion point for x in array to maintain sorted order
        *
        * @param arr Array to search
        * @param x Value to serch for insertion point
        * @param low Minimum value of array subset
        * @param high Maximum value of array subset
        */
        bisectLeft: (arr: any[], x: any, low?: number, high?: number) => number;
        /**
        * Locate the insertion point for x in array to maintain sorted order
        *
        * @param arr Array to search
        * @param x Value to serch for insertion point
        * @param low Minimum value of array subset
        * @param high Maximum value of array subset
        */
        bisectRight: (arr: any[], x: any, low?: number, high?: number) => number;
        /**
        * Bisect using an accessor.
        *
        * @param accessor Accessor function
        */
        bisector(accessor: (data: any, index: number) => any): any;
        /**
        * Randomize the order of an array.
        *
        * @param arr Array to randomise
        */
        shuffle(arr: any[]): any[];
        /**
        * Reorder an array of elements according to an array of indexes
        *
        * @param arr Array to reorder
        * @param indexes Array containing the order the elements should be returned in
        */
        permute(arr: any[], indexes: any[]): any[];
        /**
        * Transpose a variable number of arrays.
        *
        * @param arrs Arrays to transpose
        */
        zip(...arrs: any[]): any[];
        /**
        * Transpose an array of arrays.
        *
        * @param matrix Two dimensional array to transpose
        */
        transpose(matrix: any[]): any[];
        /**
        * List the keys of an associative array.
        *
        * @param map Array of objects to get the key values from
        */
        keys(map: any[]): any[];
        /**
        * List the values of an associative array.
        *
        * @param map Array of objects to get the values from
        */
        values(map: any[]): any[];
        /**
        * List the key-value entries of an associative array.
        *
        * @param map Array of objects to get the key-value pairs from
        */
        entries(map: any[]): any[];
        /**
        * merge multiple arrays into one array
        *
        * @param map Arrays to merge
        */
        merge(...map: any[]): any[];
        /**
        * Generate a range of numeric values.
        */
        range: {
            /**
            * Generate a range of numeric values from 0.
            *
            * @param stop Value to generate the range to
            * @param step Step between each value
            */
            (stop: number, step?: number): number[];
            /**
            * Generate a range of numeric values.
            *
            * @param start Value to start
            * @param stop Value to generate the range to
            * @param step Step between each value
            */
            (start: number, stop?: number, step?: number): number[];
        };
        /**
        * Create new nest operator
        */
        nest(): Nest;

        /**
        * Request a resource using XMLHttpRequest.
        */
        xhr: {
            /**
            * Creates an asynchronous request for specified url
            *
            * @param url Url to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, callback?: (xhr: XMLHttpRequest) => void ): Xhr;
            /**
            * Creates an asynchronous request for specified url
            *
            * @param url Url to request
            * @param mime MIME type to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, mime: string, callback?: (xhr: XMLHttpRequest) => void ): Xhr;
        };
        /**
        * Request a text file
        */
        text: {
            /**
            * Request a text file
            *
            * @param url Url to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, callback?: (response: string) => void ): Xhr;
            /**
            * Request a text file
            *
            * @param url Url to request
            * @param mime MIME type to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, mime: string, callback?: (response: string) => void ): Xhr;
        };
        /**
        * Request a JSON blob
        *
        * @param url Url to request
        * @param callback Function to invoke when resource is loaded or the request fails
        */
        json: (url: string, callback?: (response: any) => void ) => Xhr;
        /**
        * Request an HTML document fragment.
        */
        xml: {
            /**
            * Request an HTML document fragment.
            *
            * @param url Url to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, callback?: (response: Document) => void ): Xhr;
            /**
            * Request an HTML document fragment.
            *
            * @param url Url to request
            * @param mime MIME type to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, mime: string, callback?: (response: Document) => void ): Xhr;
        };
        /**
        * Request an XML document fragment.
        *
        * @param url Url to request
        * @param callback Function to invoke when resource is loaded or the request fails
        */
        html: (url: string, callback?: (response: DocumentFragment) => void ) => Xhr;
        /**
        * Request a comma-separated values (CSV) file.
        */
        csv: {
            /**
            * Request a comma-separated values (CSV) file.
            *
            * @param url Url to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, callback?: (error: any, response: any[]) => void ): Xhr;
            /**
            * Parse a CSV string into objects using the header row.
            *
            * @param string CSV formatted string to parse
            */
            parse(string: string): any[];
            /**
            * Parse a CSV string into tuples, ignoring the header row.
            *
            * @param string CSV formatted string to parse
            */
            parseRows(string: string, accessor: (row: any[], index: number) => any): any;
            /**
            * Format an array of tuples into a CSV string.
            *
            * @param rows Array to convert to a CSV string
            */
            format(rows: any[]): string;
        };
        /**
        * Request a tab-separated values (TSV) file
        */
        tsv: {
            /**
            * Request a tab-separated values (TSV) file
            *
            * @param url Url to request
            * @param callback Function to invoke when resource is loaded or the request fails
            */
            (url: string, callback?: (error: any, response: any[]) => void ): Xhr;
            /**
            * Parse a TSV string into objects using the header row.
            *
            * @param string TSV formatted string to parse
            */
            parse(string: string): any[];
            /**
            * Parse a TSV string into tuples, ignoring the header row.
            *
            * @param string TSV formatted string to parse
            */
            parseRows(string: string, accessor: (row: any[], index: number) => any): any;
            /**
            * Format an array of tuples into a TSV string.
            *
            * @param rows Array to convert to a TSV string
            */
            format(rows: any[]): string;
        };

        /**
        * Time Functions
        */
        time: Time;

        /**
        * Scales
        */
        scale: {
            /**
            * Construct a linear quantitative scale.
            */
            linear(): LinearScale;
            /*
            * Construct an ordinal scale.
            */
            ordinal(): OrdinalScale;
            /**
            * Construct a linear quantitative scale with a discrete output range.
            */
            quantize(): QuantizeScale;
            /*
            * Construct an ordinal scale with ten categorical colors.
            */
            category10(): OrdinalScale;
            /*
            * Construct an ordinal scale with twenty categorical colors
            */
            category20(): OrdinalScale;
            /*
            * Construct an ordinal scale with twenty categorical colors
            */
            category20b(): OrdinalScale;
            /*
            * Construct an ordinal scale with twenty categorical colors
            */
            category20c(): OrdinalScale;
        };
        /*
        * Interpolate two values
        */
        interpolate: BaseInterpolate;
        /*
        * Interpolate two numbers
        */
        interpolateNumber: BaseInterpolate;
        /*
        * Interpolate two integers
        */
        interpolateRound: BaseInterpolate;
        /*
        * Interpolate two strings
        */
        interpolateString: BaseInterpolate;
        /*
        * Interpolate two RGB colours
        */
        interpolateRgb: BaseInterpolate;
        /*
        * Interpolate two HSL colours
        */
        interpolateHsl: BaseInterpolate;
        /*
        * Interpolate two arrays of values
        */
        interpolateArray: BaseInterpolate;
        /*
        * Interpolate two arbitary objects
        */
        interpolateObject: BaseInterpolate;
        /*
        * Interpolate two 2D matrix transforms
        */
        interpolateTransform: BaseInterpolate;

        /**
        * Layouts
        */
        layout: Layout;

        /**
        * Svg's
        */
        svg: Svg;

        /**
        * Random number generators
        */
        random: Random;

        /**
        * Create a function to format a number as a string
        *
        * @param specifier The format specifier to use
        */
        format(specifier: string): (value: number) => string;
    }

    interface Xhr {
        /**
        * Get or set request header
        */
        header: {
            /**
            * Get the value of specified request header
            *
            * @param name Name of header to get the value for
            */
            (name: string): string;
            /**
            * Set the value of specified request header
            *
            * @param name Name of header to set the value for
            * @param value Value to set the header to
            */
            (name: string, value: string): Xhr;
        };
        /**
        * Get or set MIME Type
        */
        mimeType: {
            /**
            * Get the current MIME Type
            */
            (): string;
            /**
            * Set the MIME Type for the request
            *
            * @param type The MIME type for the request
            */
            (type: string): Xhr;
        };
        /*
        * Get or Set the function used to map the response to the associated data value
        */
        response: {
            /**
            * Get function used to map the response to the associated data value
            */
            (): (xhr: XMLHttpRequest) => any;
            /**
            * Set function used to map the response to the associated data value
            *
            * @param value The function used to map the response to a data value
            */
            (value: (xhr: XMLHttpRequest) => any ): Xhr;
        };
        /**
        * Issue the request using the GET method
        *
        * @param callback Function to invoke on completion of request
        */
        get (callback?: (xhr: XMLHttpRequest) => void ): Xhr;
        /**
        * Issue the request using the POST method
        */
        post: {
            /**
            * Issue the request using the POST method
            *
            * @param callback Function to invoke on completion of request
            */
            (callback?: (xhr: XMLHttpRequest) => void ): Xhr;
            /**
            * Issue the request using the POST method
            *
            * @param data Data to post back in the request
            * @param callback Function to invoke on completion of request
            */
            (data: any, callback?: (xhr: XMLHttpRequest) => void ): Xhr;
        };
        /**
        * Issues this request using the specified method
        */
        send: {
            /**
            * Issues this request using the specified method
            *
            * @param method Method to use to make the request
            * @param callback Function to invoke on completion of request
            */
            (method: string, callback?: (xhr: XMLHttpRequest) => void ): Xhr;
            /**
            * Issues this request using the specified method
            *
            * @param method Method to use to make the request
            * @param data Data to post back in the request
            * @param callback Function to invoke on completion of request
            */
            (method: string, data: any, callback?: (xhr: XMLHttpRequest) => void ): Xhr;
        };
        /**
        * Aborts this request, if it is currently in-flight
        */
        abort(): Xhr;
        /**
        * Registers a listener to receive events
        *
        * @param type Enent name to attach the listener to
        * @param listener Function to attach to event
        */
        on: (type: string, listener: (data: any, index?: number) => any) => Xhr;
    }

    interface Selection extends Selectors {
        attr: {
            (name: string): string;
            (name: string, value: any): Selection;
            (name: string, valueFunction: (data: any, index: number) => any): Selection;
        };

        classed: {
            (name: string): string;
            (name: string, value: any): Selection;
            (name: string, valueFunction: (data: any, index: number) => any): Selection;
        };

        style: {
            (name: string): string;
            (name: string, value: any, priority?: string): Selection;
            (name: string, valueFunction: (data: any, index: number) => any, priority?: string): Selection;
        };

        property: {
            (name: string): void;
            (name: string, value: any): Selection;
            (name: string, valueFunction: (data: any, index: number) => any): Selection;
        };

        text: {
            (): string;
            (value: any): Selection;
            (valueFunction: (data: any, index: number) => any): Selection;
        };

        html: {
            (): string;
            (value: any): Selection;
            (valueFunction: (data: any, index: number) => any): Selection;
        };

        append: (name: string) => Selection;
        insert: (name: string, before: string) => Selection;
        remove: () => Selection;

        data: {
            (values: (data: any, index: number) => any): UpdateSelection;
            (values: any[], key?: (data: any, index: number) => any): UpdateSelection;
        };

        datum: {
            (values: (data: any, index: number) => any): UpdateSelection;
            (values: any): UpdateSelection;
        };

        filter: {
            (filter: (data: any, index: number) => bool): UpdateSelection;
            (filter: string): UpdateSelection;
        };

        call(callback: (selection: Selection) => void ): Selection;
        each(eachFunction: (data: any, index: number) => any): Selection;
        on: {
            (type: string): (data: any, index: number) => any;
            (type: string, listener: (data: any, index: number) => any, capture?: bool): Selection;
        };

        transition: () => Transition;
    }

    interface EnterSelection {
        append: (name: string) => Selection;
        insert: (name: string, before: string) => Selection;
        select: (selector: string) => Selection;
        empty: () => bool;
        node: () => Node;
    }

    interface UpdateSelection extends Selection {
        enter: () => EnterSelection;
        update: () => Selection;
        exit: () => Selection;
    }

    interface Transition {
        duration: {
            (duration: number): Transition;
            (duration: (data: any, index: number) => any): Transition;
        };
        delay: {
            (delay: number): Transition;
            (delay: (data: any, index: number) => any): Transition;
        };
        attr: {
            (name: string): string;
            (name: string, value: any): Transition;
            (name: string, valueFunction: (data: any, index: number) => any): Transition;
        };
        call(callback: (selection: Selection) => void ): Transition;

        select: (selector: string) => Transition;
        selectAll: (selector: string) => Transition;

        each: (type?: string, eachFunction?: (data: any, index: number) => any) => Transition;
        transition: () => Transition;
        ease: (value: string, ...arrs: any[]) => Transition;
    }

    interface Nest {
        key(keyFunction: (data: any, index: number) => any): Nest;
        rollup(rollupFunction: (data: any, index: number) => any): Nest;
        map(values: any[]): Nest;
    }

    interface Time {
        second: Interval;
        minute: Interval;
        hour: Interval;
        day: Interval;
        week: Interval;
        sunday: Interval;
        monday: Interval;
        tuesday: Interval;
        wednesday: Interval;
        thursday: Interval;
        friday: Interval;
        saturday: Interval;
        month: Interval;
        year: Interval;

        seconds: Range;
        minutes: Range;
        hours: Range;
        days: Range;
        weeks: Range;
        months: Range;
        years: Range;

        sundays: Range;
        mondays: Range;
        tuesdays: Range;
        wednesdays: Range;
        thursdays: Range;
        fridays: Range;
        saturdays: Range;
        format: {

            (specifier: string): TimeFormat;
            utc: (specifier: string) => TimeFormat;
            iso: TimeFormat;
        };

        scale(): TimeScale;
    }

    interface Range {
        (start: Date, end: Date, step?: number): Date[];
    }

    interface Interval {
        (date: Date): Date;
        floor: (date: Date) => Date;
        round: (date: Date) => Date;
        ceil: (date: Date) => Date;
        range: Range;
        offset: (date: Date, step: number) => Date;
        utc: Interval;
    }

    interface TimeFormat {
        (date: Date): string;
        parse: (string: string) => Date;
    }

    interface Scale {
        (value: any): any;
        domain: {
            (values: any[]): Scale;
            (): any[];
        };
        range: {
            (values: any[]): Scale;
            (): any[];
        };
        copy: Scale;
    }

    interface LinearScale extends Scale {
        (value: number): number;
        invert(value: number): number;
        domain(numbers: any[]): LinearScale;
        range: {
            (values: any[]): LinearScale;
            (): any[];
        };
        rangeRound: (values: any[]) => LinearScale;
        interpolate: {
            (): Interpolate;
            (factory: Interpolate): LinearScale;
        };
        clamp(clamp: bool): LinearScale;
        nice(): LinearScale;
        ticks(count: number): any[];
        tickFormat(count: number): (n: number) => string;
        copy: LinearScale;
    }

    interface OrdinalScale extends Scale {
        (value: any): any;
        domain: {
            (values: any[]): OrdinalScale;
            (): any[];
        };
        range: {
            (values: any[]): OrdinalScale;
            (): any[];
        };
        rangePoints(interval: any[], padding?: number): OrdinalScale;
        rangeBands(interval: any[], padding?: number, outerPadding?: number): OrdinalScale;
        rangeRoundBands(interval: any[], padding?: number, outerPadding?: number): OrdinalScale;
        rangeBand(): number;
        rangeExtent(): any[];
        copy: OrdinalScale;
    }

    interface QuantizeScale extends Scale {
        (value: any): any;
        domain: {
            (values: number[]): QuantizeScale;
            (): any[];
        };
        range: {
            (values: any[]): QuantizeScale;
            (): any[];
        };
        copy: QuantizeScale;
    }

    interface TimeScale extends Scale {
        (value: Date): number;
        invert(value: number): Date;
        domain(numbers: any[]): TimeScale;
        range: {
            (values: any[]): TimeScale;
            (): any[];
        };
        rangeRound: (values: any[]) => TimeScale;
        interpolate: {
            (): Interpolate;
            (factory: InterpolateFactory): TimeScale;
        };
        clamp(clamp: bool): TimeScale;
        ticks: {
            (count: number): any[];
            (range: Range, count: number): any[];
        };
        tickFormat(count: number): (n: number) => string;
        copy(): TimeScale;
    }

    interface InterpolateFactory {
        (a: any, b: any): BaseInterpolate;
    }
    interface BaseInterpolate {
        (a: any, b: any): Interpolate;
    }

    interface Interpolate {
        (t: number): number;
    }

    interface Layout {
        stack(): StackLayout;
        pie(): PieLayout;
    }

    interface StackLayout {
        (layers: any[], index?: number): any[];
        values(accessor?: (d: any) => any): StackLayout;
        offset(offset: string): StackLayout;
    }

    interface PieLayout {
        (values: any[], index?: number): ArcDescriptor[];
        value: {
            (): (d: any, index: number) => number;
            (accessor: (d: any, index: number) => number): PieLayout;
        };
        sort: {
            (): (d1: any, d2: any) => number;
            (comparator: (d1: any, d2: any) => number): PieLayout;
        };
        startAngle: {
            (): number;
            (angle: number): Arc;
            (angle: () => number): Arc;
        };
        endAngle: {
            (): number;
            (angle: number): Arc;
            (angle: () => number): Arc;
        };
    }

    interface ArcDescriptor {
        value: any;
        data: any;
        startAngle: number;
        endAngle: number;
    }

    interface Symbol {
        type: (string) => Symbol;
        size: (number) => Symbol;
    }

    interface Svg {
        /**
        * Create a new symbol generator
        */
        symbol: () => Symbol;
        /**
        * Create a new axis generator
        */
        axis(): Axis;
        /**
        * Create a new arc generator
        */
        arc(): Arc;
        /**
        * Create a new line generator
        */
        line(): Line;
        /**
        * Create a new area generator
        */
        area(): Area;
    }

    interface Axis {
        (selection: Selection): void;
        scale: {
            (): any;
            (scale: any): Axis;
        };

        orient: {
            (): string;
            (orientation: string): Axis;
        };

        ticks: {
            (count: number): Axis;
            (range: Range, count?: number): Axis;
        };

        tickSubdivide(count: number): Axis;
        tickSize(major?: number, minor?: number, end?: number): Axis;
        tickFormat(formatter: (value: any) => string): Axis;
    }

    interface Arc {
        (options?: ArcOptions): string;
        innerRadius: {
            (): number;
            (radius: number): Arc;
            (radius: () => number): Arc;
        };
        outerRadius: {
            (): number;
            (radius: number): Arc;
            (radius: () => number): Arc;
        };
        startAngle: {
            (): number;
            (angle: number): Arc;
            (angle: () => number): Arc;
        };
        endAngle: {
            (): number;
            (angle: number): Arc;
            (angle: () => number): Arc;
        };
        centroid(options?: ArcOptions): number[];
    }

    interface ArcOptions {
        innerRadius?: number;
        outerRadius?: number;
        startAngle?: number;
        endAngle?: number;
    }

    interface Line {
        /**
        * Returns the path data string
        *
        * @param data Array of data elements
        * @param index Optional index
        */
        (data: any[], index?: number): string;
        /**
        * Get or set the x-coordinate accessor.
        */
        x: {
            /**
            * Get the x-coordinate accessor.
            */
            (): (data: any) => any;
            /**
            * Set the x-coordinate accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Line;
        };
        /**
        * Get or set the y-coordinate accessor.
        */
        y: {
            /**
            * Get the y-coordinate accessor.
            */
            (): (data: any) => any;
            /**
            * Set the y-coordinate accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Line;
        };
        /**
        * Get or set the interpolation mode.
        */
        interpolate: {
            /**
            * Get the interpolation accessor.
            */
            (): string;
            /**
            * Set the interpolation accessor.
            *
            * @param interpolate The interpolation mode
            */
            (interpolate: string): Line;
        };
        /**
        * Get or set the cardinal spline tension.
        */
        tension: {
            /**
            * Get the cardinal spline accessor.
            */
            (): number;
            /**
            * Set the cardinal spline accessor.
            *
            * @param tension The Cardinal spline interpolation tension
            */
            (tension: number): Line;
        };
        /**
        * Control whether the line is defined at a given point.
        */
        defined: {
            /**
            * Get the accessor function that controls where the line is defined.
            */
            (): (data: any) => any;
            /**
            * Set the accessor function that controls where the area is defined.
            *
            * @param defined The new accessor function
            */
            (defined: (data: any) => any): Line;
        };
    }

    interface Area {
        /**
        * Generate a piecewise linear area, as in an area chart.
        */
        (data: any[], index?: number): string;
        /**
        * Get or set the x-coordinate accessor.
        */
        x: {
            /**
            * Get the x-coordinate accessor.
            */
            (): (data: any) => any;
            /**
            * Set the x-coordinate accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the x0-coordinate (baseline) accessor.
        */
        x0: {
            /**
            * Get the  x0-coordinate (baseline) accessor.
            */
            (): (data: any) => any;
            /**
            * Set the  x0-coordinate (baseline) accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the x1-coordinate (topline) accessor.
        */
        x1: {
            /**
            * Get the  x1-coordinate (topline) accessor.
            */
            (): (data: any) => any;
            /**
            * Set the  x1-coordinate (topline) accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the y-coordinate accessor.
        */
        y: {
            /**
            * Get the y-coordinate accessor.
            */
            (): (data: any) => any;
            /**
            * Set the y-coordinate accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the y0-coordinate (baseline) accessor.
        */
        y0: {
            /**
            * Get the y0-coordinate (baseline) accessor.
            */
            (): (data: any) => any;
            /**
            * Set the y0-coordinate (baseline) accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the y1-coordinate (topline) accessor.
        */
        y1: {
            /**
            * Get the y1-coordinate (topline) accessor.
            */
            (): (data: any) => any;
            /**
            * Set the y1-coordinate (topline) accessor.
            *
            * @param accessor The new accessor function
            */
            (accessor: (data: any) => any): Area;
        };
        /**
        * Get or set the interpolation mode.
        */
        interpolate: {
            /**
            * Get the interpolation accessor.
            */
            (): string;
            /**
            * Set the interpolation accessor.
            *
            * @param interpolate The interpolation mode
            */
            (interpolate: string): Area;
        };
        /**
        * Get or set the cardinal spline tension.
        */
        tension: {
            /**
            * Get the cardinal spline accessor.
            */
            (): number;
            /**
            * Set the cardinal spline accessor.
            *
            * @param tension The Cardinal spline interpolation tension
            */
            (tension: number): Area;
        };
        /**
        * Control whether the area is defined at a given point.
        */
        defined: {
            /**
            * Get the accessor function that controls where the area is defined.
            */
            (): (data: any) => any;
            /**
            * Set the accessor function that controls where the area is defined.
            *
            * @param defined The new accessor function
            */
            (defined: (data: any) => any): Area;
        };
    }

    interface Random {
        /**
        * Returns a function for generating random numbers with a normal distribution
        *
        * @param mean The expected value of the generated pseudorandom numbers
        * @param deviation The given standard deviation
        */
        normal(mean?: number, deviation?: number): () => number;
        /**
        * Returns a function for generating random numbers with a log-normal distribution
        *
        * @param mean The expected value of the generated pseudorandom numbers
        * @param deviation The given standard deviation
        */
        logNormal(mean?: number, deviation?: number): () => number;
        /**
        * Returns a function for generating random numbers with an Irwin-Hall distribution
        *
        * @param count The number of independent variables
        */
        irwinHall(count: number): () => number;
    }
}

declare var d3: D3.Base;


text:
using System;
using System.Xml.Serialization;

namespace EZOper.NetSiteUtilities.AopApi
{
    /// <summary>
    /// AlipayMarketingUserulePidQueryResponse.
    /// </summary>
    public class AlipayMarketingUserulePidQueryResponse : AopResponse
    {
        /// <summary>
        /// 满足条件的所有pid,多个pid使用英文逗号隔开
        /// </summary>
        [XmlElement("pids")]
        public string Pids { get; set; }
    }
}