text:
package com.pl.app;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.RemoteViews;

import butterknife.BindView;
import butterknife.ButterKnife;

public class NotificationTestActivity extends AppCompatActivity implements View.OnClickListener {

    @BindView(R.id.button1) Button btn1;
    @BindView(R.id.button2) Button btn2;
    private static int sId = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_notification_test);
        ButterKnife.bind(this);
        //btn1 = (Button) findViewById(R.id.button1);
        btn1.setOnClickListener(this);
        //btn2 = (Button) findViewById(R.id.button2);
        btn2.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        Notification notification = new Notification();
        notification.icon = R.mipmap.ic_launcher;
        notification.tickerText = "Hello World";
        notification.when = System.currentTimeMillis();
        notification.flags = Notification.FLAG_AUTO_CANCEL;
        Intent intent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
        if (v == btn1) {
            sId++;
            notification.setLatestEventInfo(this, "notification_test", "This is a notification...", pendingIntent);
        } else if (v == btn2) {
            RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.layout_notification_test);
            remoteViews.setTextViewText(R.id.tv_msg, "Notification test: " + sId);
            remoteViews.setOnClickPendingIntent(R.id.btn_response, pendingIntent);
            notification.contentView = remoteViews;
        }
        NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        manager.notify(sId, notification);
    }

}


text:
(async function() {
  TestRunner.addResult(`Tests that elements tab updates after a bf-cache navigation.\n`);
  await TestRunner.loadTestModule('elements_test_runner');
  await TestRunner.showPanel('elements');

  // Save time on style updates.
  ElementsTestRunner.ignoreSidebarUpdates();

  const expandAndDumpTree = () => new Promise(resolve => {
    ElementsTestRunner.expandElementsTree(() => {
      ElementsTestRunner.dumpElementsTree();
      resolve();
    });
  });

  // TestRunner.navigate navigates with replacement, so we need to separately
  // define a method to navigate without replacement (need this for bf-cache
  // testing).
  // TODO(adithyas): Add this to a utils file or to TestRunner.js.
  const navigate = url => new Promise(resolve => {
    TestRunner.evaluateInPage(`window.location.href = '${url}'`);
    TestRunner.waitForPageLoad(resolve);
  });

  await TestRunner.navigatePromise('http://localhost:8000/devtools/bfcache/resources/page1.html');
  await navigate('http://devtools.oopif.test:8000/devtools/bfcache/resources/page2.html');
  await expandAndDumpTree();

  // Navigate back - uses BFCache.
  TestRunner.evaluateInPage('window.history.back()');
  await TestRunner.waitForEvent(SDK.DOMModel.Events.DocumentUpdated, TestRunner.domModel);
  await expandAndDumpTree();

  TestRunner.completeTest();
})();

redpajama_set_name: RedPajamaGithub


text:
from babel.core import *

from django.conf import settings
from django.utils.encoding import smart_unicode
settings.configure(USE_I18N=True)
from django.template import Lexer, TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK
from django.utils.translation.trans_real import inline_re, block_re, \
                                                endblock_re, plural_re, \
                                                constant_re

def extract_django(fileobj, keywords, comment_tags, options):
    """Extract messages from Django template files.

    :param fileobj: the file-like object the messages should be extracted from
    :param keywords: a list of keywords (i.e. function names) that should
                     be recognized as translation functions
    :param comment_tags: a list of translator tags to search for and
                         include in the results
    :param options: a dictionary of additional options (optional)
    :return: an iterator over ``(lineno, funcname, message, comments)``
             tuples
    :rtype: ``iterator``
    """
    intrans = False
    inplural = False
    singular = []
    plural = []
    lineno = 1
    for t in Lexer(fileobj.read(), None).tokenize():
        lineno += t.contents.count('\n')
        if intrans:
            if t.token_type == TOKEN_BLOCK:
                endbmatch = endblock_re.match(t.contents)
                pluralmatch = plural_re.match(t.contents)
                if endbmatch:
                    if inplural:
                        yield lineno, 'ngettext', (smart_unicode(''.join(singular)),
                                                   smart_unicode(''.join(plural))), []
                    else:
                        yield lineno, None, smart_unicode(''.join(singular)), []
                    intrans = False
                    inplural = False
                    singular = []
                    plural = []
                elif pluralmatch:
                    inplural = True
                else:
                    raise SyntaxError('Translation blocks must not include '
                                      'other block tags: %s' % t.contents)
            elif t.token_type == TOKEN_VAR:
                if inplural:
                    plural.append('%%(%s)s' % t.contents)
                else:
                    singular.append('%%(%s)s' % t.contents)
            elif t.token_type == TOKEN_TEXT:
                if inplural:
                    plural.append(t.contents)
                else:
                    singular.append(t.contents)
        else:
            if t.token_type == TOKEN_BLOCK:
                imatch = inline_re.match(t.contents)
                bmatch = block_re.match(t.contents)
                cmatches = constant_re.findall(t.contents)
                if imatch:
                    g = imatch.group(1)
                    if g[0] == '"':
                        g = g.strip('"')
                    elif g[0] == "'":
                        g = g.strip("'")
                    yield lineno, None, smart_unicode(g), []
                elif bmatch:
                    for fmatch in constant_re.findall(t.contents):
                        yield lineno, None, smart_unicode(fmatch), []
                    intrans = True
                    inplural = False
                    singular = []
                    plural = []
                elif cmatches:
                    for cmatch in cmatches:
                        yield lineno, None, smart_unicode(cmatch), []
            elif t.token_type == TOKEN_VAR:
                parts = t.contents.split('|')
                cmatch = constant_re.match(parts[0])
                if cmatch:
                    yield lineno, None, smart_unicode(cmatch.group(1)), []
                for p in parts[1:]:
                    if p.find(':_(') >= 0:
                        p1 = p.split(':',1)[1]
                        if p1[0] == '_':
                            p1 = p1[1:]
                        if p1[0] == '(':
                            p1 = p1.strip('()')
                        if p1[0] == "'":
                            p1 = p1.strip("'")
                        elif p1[0] == '"':
                            p1 = p1.strip('"')
                        yield lineno, None, smart_unicode(p1), []


text:
from openstack import resource
from openstack import utils
from rackspace.monitoring import monitoring_service

class Notification(resource.Resource):
    base_path = 'notifications'
    resources_key = 'values'
    service = monitoring_service.MonitoringService()

    # capabilities
    allow_create = True
    allow_delete = True
    allow_list = True
    allow_retrieve = True
    allow_update = True

    # Properties
    #: Details specific to the notification. *Type: dict*
    details = resource.prop('details', type=dict)
    #: A friendly label for the notification type
    name = resource.prop('label')
    #: The type of notification to send
    type = resource.prop('type')

    def test(self, session):
        """Test an existing notification

        The notification comes from the same server that the alert messages
        come from. One use for this test is to verify that your firewall is
        configured properly.

        :param session: The session to use for making this request.
        :type session: :class:`~openstack.session.Session`
        :returns: ``dict``
        """
        url = utils.urljoin(self.base_path, self.id, 'test')
        return session.post(url, endpoint_filter=self.service).body


text:
// Reference from: https://github.com/facebook/nuclide/blob/84be9ca477228836e1c83b1d5aa47848faa49e17/flow-libs/electron.js.flow

// The properties on this module depend on whether the importer is the main
// process or a renderer process.
declare module 'electron' {
  // Main process:
  declare var app: electron$app;
  declare var autoUpdater: electron$autoUpdater;
  declare var BrowserWindow: typeof electron$BrowserWindow;
  declare var contentTracing: electron$contentTracing;
  declare var dialog: electron$dialog;
  declare var globalShortcut: electron$globalShortcut;
  declare var ipcMain: electron$IpcMain;
  declare var Menu: typeof electron$Menu;
  declare var MenuItem: typeof electron$MenuItem;
  declare var powerMonitor: electron$powerMonitor;
  declare var powerSaveBlocker: electron$powerSaveBlocker;
  declare var protocol: electron$protocol;
  declare var session: electron$session;
  declare var electron$Tray: typeof electron$Tray;
  declare var webContents: electron$webContents;

  // Renderer process:
  declare var desktopCapturer: electron$desktopCapturer;
  declare var ipcRenderer: electron$IpcRenderer;
  declare var remote: electron$remote;
  declare var webFrame: electron$webFrame;

  // Both:
  declare var clipboard: electron$clipboard;
  declare var crashReporter: electron$crashReporter;
  declare var nativeImage: electron$nativeImage;
  declare var screen: electron$Screen;
  declare var shell: electron$shell;

  // declare type BrowserWindow = electron$BrowserWindow;
  // declare type Menu = electron$Menu;
  // declare type MenuItem = electron$MenuItem;
  declare type BrowserWindowOptions = electron$BrowserWindowOptions;
  declare type MenuItemOptions = electron$MenuItemOptions;
  declare type DialogOpenOptions = electron$dialogOpenOptions;
  // declare type NativeImage = electron$NativeImage;
  // declare type Screen = electron$Screen;
  declare type WebContents = electron$WebContents;

  declare type BrowserWindowEvents = electron$BrowserWindowEvents
  declare type WebContentsEvents = electron$WebContentsEvents
}

// very common struct
type electron$rect = {
  x: number,
  y: number,
  width: number,
  height: number,
};

//------------------------------------------------------------------------------
// Custom DOM Elements
//------------------------------------------------------------------------------

/**
 * https://github.com/electron/electron/blob/master/docs/api/file-object.md
 */

// HTML5 File API but with a `path` attribute added.

/**
 * https://github.com/electron/electron/blob/master/docs/api/web-view-tag.md
 */

declare class WebviewElement extends HTMLElement {
  src: string,
  nodeintegration: boolean,
  disablewebsecurity: boolean,

  executeJavaScript(code: string, userGesture: ?boolean): void,
  getTitle(): string,
  // This used to be `getUrl`, but the old version was dropped in the electron bundled with Atom
  // 1.12, and the new version exists at least in Atom 1.10.2 onward.
  getURL(): string,
  // Not sure when this was introduced
  stop?: () => void,
  insertCSS(code: string): void,
  send(channel: string, ...args: Array<any>): void,
  openDevTools(): void,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/window-open.md
 */

// window.open

//------------------------------------------------------------------------------
// Modules for the Main Process
//------------------------------------------------------------------------------

/**
 * https://github.com/electron/electron/blob/master/docs/api/app.md
 */

type electron$appEvents =
  | 'will-finish-launching'
  | 'ready'
  | 'window-all-closed'
  | 'before-quit'
  | 'will-quit'
  | 'quit'
  | 'open-file'
  | 'open-url'
  | 'activate'
  | 'continue-activity'
  | 'browser-window-blur'
  | 'browser-window-focus'
  | 'browser-window-created'
  | 'web-contents-created'
  | 'certificate-error'
  | 'select-client-certificate'
  | 'login'
  | 'gpu-process-crashed'
  | 'accessibility-support-changed'

type electron$appListener = (
  event: electron$appEvents,
  callback: (event: Object, ...args: Array<any>) => void | Promise<void>,
) => electron$app;

type electron$app = {
  quit(): void,
  exit(exitCode?: number): void,
  relaunch(options?: {args?: Array<string>, execPath?: string}): void,
  isReady(): boolean,
  focus(): void,
  getAppPath(): string,
  getPath(name: string): string,
  setPath(name: string, path: string): void,
  getVersion(): string,
  getName(): string,
  setName(name: string): void,
  getLocale(): string,
  makeSingleInstance(callback: (argv: Array<string>, workingDirectory: string) => void): boolean,
  releaseSingleInstance(): void,
  disableHardwareAcceleration(): void,

  on: electron$appListener,
  once: electron$appListener,
  removeAllListeners(event?: electron$appEvents): electron$app,
  removeListener(event?: electron$appEvents, callback: Function): electron$app,
};

/**
 * https://github.com/electron/electron/blob/master/docs/api/auto-updater.md
 */

type electron$autoUpdater = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/browser-window.md
 */

type electron$BrowserWindowOptions = {
  width?: number,
  height?: number,
  x?: number,
  y?: number,
  useContentSize?: boolean,
  center?: boolean,
  minWidth?: number,
  minHeight?: number,
  maxWidth?: number,
  maxHeight?: number,
  resizable?: boolean,
  movable?: boolean,
  minimizable?: boolean,
  maximizable?: boolean,
  closable?: boolean,
  focusable?: boolean,
  alwaysOnTop?: boolean,
  fullscreen?: boolean,
  fullscreenable?: boolean,
  skipTaskbar?: boolean,
  kiosk?: boolean,
  title?: string,
  icon?: electron$NativeImage,
  show?: boolean,
  frame?: boolean,
  parent?: electron$BrowserWindow,
  modal?: boolean,
  acceptFirstMouse?: boolean,
  disableAutoHideCursor?: boolean,
  autoHideMenuBar?: boolean,
  enableLargerThanScreen?: boolean,
  backgroundColor?: string,
  hasShadow?: boolean,
  darkTheme?: boolean,
  transparent?: boolean,
  type?: 'desktop' | 'dock' | 'toolbar' | 'splash' | 'notification' |
         /* macOS */ 'desktop' | 'textured' |
         /* Windows */ 'toolbar',
  titleBarStyle?: 'default' | 'hidden' | 'hidden-inset',
  thickFrame?: boolean,
  webPreferences?: electron$BrowserWindowWebPreferences,
};

type electron$BrowserWindowWebPreferences = {
  nodeIntegration?: boolean,
  preload?: string,
  session?: electron$session,
  partition?: string,
  zoomFactor?: number,
  javascript?: boolean,
  webSecurity?: boolean,
  allowDisplayingInsecureContent?: boolean,
  allowRunningInsecureContent?: boolean,
  images?: boolean,
  textAreasAreResizable?: boolean,
  webgl?: boolean,
  webaudio?: boolean,
  plugins?: boolean,
  experimentalFeatures?: boolean,
  experimentalCanvasFeatures?: boolean,
  scrollBounce?: boolean,
  blinkFeatures?: string,
  disableBlinkFeatures?: string,
  defaultFontFamily?: {
    standard?: string,
    serif?: string,
    sansSerif?: string,
    monospace?: string,
  },
  defaultFontSize?: number,
  defaultMonospaceFontSize?: number,
  minimumFontSize?: number,
  defaultEncoding?: string,
  backgroundThrottling?: boolean,
  offscreen?: boolean,
};

type electron$BrowserWindowEvents =
  | 'page-title-updated'
  | 'close'
  | 'closed'
  | 'unresponsive'
  | 'responsive'
  | 'blur'
  | 'focus'
  | 'show'
  | 'hide'
  | 'ready-to-show'
  | 'maximize'
  | 'unmaximize'
  | 'minimize'
  | 'restore'
  | 'resize'
  | 'move'
  | 'moved'
  | 'enter-full-screen'
  | 'leave-full-screen'
  | 'enter-html-full-screen'
  | 'leave-html-full-screen'
  | 'app-command'         // Windows
  | 'scroll-touch-begin'  // macOS
  | 'scroll-touch-end'    // macOS
  | 'swipe';              // macOS

type electron$BrowserWindowListener = (
  event: electron$BrowserWindowEvents,
  callback: (event: Object, ...args: Array<any>) => void,
) => electron$BrowserWindow;

declare class electron$BrowserWindow {
  constructor(options: electron$BrowserWindowOptions): void,
  on: electron$BrowserWindowListener,
  once: electron$BrowserWindowListener,
  removeAllListeners(event?: electron$BrowserWindowEvents): electron$BrowserWindow,
  removeListener(event?: electron$BrowserWindowEvents, callback: Function): electron$BrowserWindow,
  send(channel: string, ...args: Array<any>): void,

  static getAllWindows(): Array<electron$BrowserWindow>,
  static getFocusedWindow(): ?electron$BrowserWindow,
  static fromWebContents(webContents: electron$WebContents): ?electron$BrowserWindow,
  static fromId(id: number): ?electron$BrowserWindow,
  static addDevToolsExtension(path: string): void,
  static removeDevToolsExtension(name: string): void,
  static getDevToolsExtensions(): {[name: string]: {[name: string]: string}},

  webContents: electron$WebContents,
  id: string,
  destroy(): void,
  close(): void,
  focus(): void,
  blur(): void,
  isFocused(): boolean,
  isDestroyed(): boolean,
  show(): void,
  showInactive(): void,
  hide(): void,
  isVisible(): boolean,
  isModal(): boolean,
  maximize(): void,
  unmaximize(): void,
  isMaximized(): boolean,
  minimize(): void,
  restore(): void,
  isMinimized(): boolean,
  setFullScreen(flag: boolean): void,
  isFullScreen(): boolean,
  setAspectRatio(aspectRatio: number, extraSize?: {width: number, height: number}): void, // macOS
  setBounds(options: electron$rect,  /* macOS */ animate?: boolean): void,
  getBounds(): electron$rect,
  setSize(width: number, height: number, /* macOS */ animate?: boolean): void,
  getSize(): [number, number],
  setContentSize(width: number, height: number, /* macOS */ animate?: boolean): void,
  getContentSize(): [number, number],
  setMinimumSize(width: number, height: number): void,
  getMinimumSize(): [number, number],
  setMaximumSize(width: number, height: number): void,
  getMaximumSize(): [number, number],
  setResizable(resizable: boolean): void,
  isResizable(): boolean,
  setMovable(movable: boolean): void, // macOS Windows
  isMovable(): boolean, // macOS Windows
  setMinimizable(minimizable: boolean): void, // macOS Windows
  isMinimizable(): boolean, // macOS Windows
  setMaximizable(maximizable: boolean): void, // macOS Windows
  isMaximizable(): boolean, // macOS Windows
  setFullScreenable(fullscreenable: boolean): void,
  isFullScreenable(): boolean,
  setClosable(closable: boolean): void, // macOS Windows
  isClosable(): boolean, // macOS Windows
  setAlwaysOnTop(flag: boolean): void,
  isAlwaysOnTop(): boolean,
  center(): void,
  setPosition(x: number, y: number, /* macOS */ animate?: boolean): void,
  getPosition(): [number, number],
  setTitle(title: string): void,
  getTitle(): string,
  setSheetOffset(offsetY: number, offsetX?: number): void, // macOS
  flashFrame(flag: boolean): void,
  setSkipTaskbar(skip: boolean): void,
  setKiosk(flag: boolean): void,
  isKiosk(): boolean,
  getNativeWindowHandle(): Buffer,
  hookWindowMessage(message: number, callback: Function): void, // Windows
  isWindowMessageHooked(message: number): boolean, // Windows
  unhookWindowMessage(message: number): void, // Windows
  unhookAllWindowMessages(): void, // Windows
  setRepresentedFilename(filename: string): void, // macOS
  getRepresentedFilename(): string, // macOS
  setDocumentEdited(edited: boolean): void, // macOS
  isDocumentEdited(): boolean, // macOS
  focusOnWebView(): void,
  blurWebView(): void,
  capturePage(rect: electron$rect, callback: (image: electron$NativeImage) => void): void,
  capturePage(callback: (image: electron$NativeImage) => void): void,
  loadURL(
    url: string,
    options?: {httpReferrer?: string, userAgent?: string, extraHeaders?: string},
  ): void,
  reload(): void,
  setMenu(menu: electron$Menu): void, // Linux Windows
  setProgressBar(progress: number): void,
  setOverlayIcon(overlay: electron$NativeImage, description: string): void, // Windows
  setHasShadow(hasShadow: boolean): void, // macOS
  hasShadow(): boolean, // macOS
  setThumbarButtons(buttons: Array<{
    icon: electron$NativeImage,
    click: Function,
    tooltip?: string,
    flags?: Array<'enabled' | 'disabled' | 'dismissonclick' | 'nobackground' |
                  'hidden' | 'noninteractive'>,
  }>): void, // Windows
  setThumbnailClip(region: electron$rect): void, // Windows
  showDefinitionForSelection(): void, // macOS
  setIcon(icon: electron$NativeImage): void, // Windows Linux
  setAutoHideMenuBar(hide: boolean): void,
  isMenuBarAutoHide(): boolean,
  setMenuBarVisibility(visible: boolean): void,
  isMenuBarVisible(): boolean,
  setVisibleOnAllWorkspaces(visible: boolean): void,
  isVisibleOnAllWorkspaces(): boolean,
  setIgnoreMouseEvents(ignore: boolean): void,
  setContentProtection(enable: boolean): void, // macOS Windows
  setFocusable(focusable: boolean): void, // Windows
  setParentWindow(parent: electron$BrowserWindow): void, // Linux macOS
  getParentWindow(): ?electron$BrowserWindow,
  getChildWindows(): Array<electron$BrowserWindow>,

  // Atom sets this during window setup (see: src/main-process/atom-window.coffee).
  loadSettings?: Object,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/content-tracing.md
 */

type electron$contentTracing = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/dialog.md
 */

type electron$dialog = {
  showOpenDialog(
    browserWindow?: electron$BrowserWindow,
    options: electron$dialogOpenOptions,
    callback?: Function,
  ): Array<string>,
  showSaveDialog(
    browserWindow?: electron$BrowserWindow,
    options: electron$dialogSaveOptions,
    callback?: Function,
  ): string,
  showMessageBox(
    browserWindow?: electron$BrowserWindow,
    options: electron$dialogMessageBoxOptions,
    callback?: Function,
  ): number,
  showErrorBox(title: string, content: string): void,
};

type FileFilter = { name: string, extensions: Array<string> };

/**
 * https://github.com/electron/electron/blob/master/docs/api/dialog.md
 * See `dialog.showOpenDialog()`
 */

type electron$dialogOpenOptions = {
  title?: string,
  defaultPath?: string,
  buttonLabel?: string,
  filters?: Array<FileFilter>,
  properties?: Array<string>,
};

/**
 * https://github.com/electron/electron/blob/master/docs/api/dialog.md
 * See `dialog.showSaveDialog()`
 */

type electron$dialogSaveOptions = {
  title?: string,
  defaultPath?: string,
  buttonLabel?: string,
  filters?: Array<FileFilter>,
};

/**
 * https://github.com/electron/electron/blob/master/docs/api/dialog.md
 * See `dialog.showMessageBox()`
 */

type electron$dialogMessageBoxOptions = {
  type?: string,
  buttons?: Array<string>,
  defaultId?: number,
  title?: string,
  message?: string,
  detail?: string,
  icon?: electron$NativeImage,
  cancelId?: number,
  noLink?: boolean,
};

/**
 * https://github.com/electron/electron/blob/master/docs/api/global-shortcut.md
 */

type electron$globalShortcut = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/ipc-main.md
 */

declare class electron$IpcMain {
  on(channel: string, callback: (...args: Array<any>) => any): electron$IpcMain,
  once(channel: string, callback: (...args: Array<any>) => any): electron$IpcMain,
  removeListener(channel: string, callback: (...args: Array<any>) => any): electron$IpcMain,
  removeAllListeners(channel?: string): electron$IpcMain,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/menu.md
 */

declare class electron$Menu {
  static setApplicationMenu(menu: electron$Menu): void,
  static getApplicationMenu(): ?electron$Menu,
  static sendActionToFirstResponder(action: string): void,
  static buildFromTemplate(templates: Array<electron$MenuItemOptions>): electron$Menu,
  popup(
    browserWindow: electron$BrowserWindow,
    x?: number,
    y?: number,
    positioningItem?: number,
  ): void,
  popup(x?: number, y?: number, positioningItem?: number): void,
  append(menuItem: electron$MenuItem): void,
  insert(pos: number, menuItem: electron$MenuItem): void,
  items: Array<electron$MenuItem>,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/menu-item.md
 */

type electron$MenuItemOptions = {
  click?: (
    menuItem: electron$MenuItem,
    browserWindow: electron$BrowserWindow,
    event: Object
  ) => void,
  role?: 'undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'pasteandmatchstyle' |
        'selectall' | 'delete' | 'minimize' | 'close' | 'quit' | 'togglefullscreen' |
         // macOS-only
        'about' | 'hide' | 'hideothers' | 'unhide' | 'front' | 'zoom' | 'window' |
        'help' | 'services',
  type?: 'normal' | 'separator' | 'submenu' | 'checkbox' | 'radio',
  label?: string,
  sublabel?: string,
  accelerator?: string,
  icon?: electron$NativeImage,
  enabled?: boolean,
  visible?: boolean,
  checked?: boolean,
  submenu?: electron$MenuItem | Array<electron$MenuItemOptions>,
  id?: string,
  position?: string,
};

declare class electron$MenuItem {
  constructor(options: electron$MenuItemOptions): void,
  enabled: boolean,
  visible: boolean,
  checked: boolean,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/power-monitor.md
 */

type electron$powerMonitor = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/power-save-blocker.md
 */

type electron$powerSaveBlocker = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/protocol.md
 */

type electron$protocol = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/session.md
 */

type electron$session = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/system-preferences.md
 */

type electron$systemPreferences = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/tray.md
 */

declare class electron$Tray {}

/**
 * https://github.com/electron/electron/blob/master/docs/api/web-contents.md
 */

type electron$InputEventModifiers =
  Array<'shift' | 'control' | 'alt' | 'meta' |
        'isKeypad' | 'isAutoRepeat' | 'leftButtonDown' | 'middleButtonDown' |
        'rightButtonDown' | 'capsLock' | 'numLock' | 'left' | 'right'>;

type electron$WebContentsEvents =
  | 'did-finish-load'
  | 'did-fail-load'
  | 'did-frame-finish-load'
  | 'did-start-loading'
  | 'did-stop-loading'
  | 'did-get-response-details'
  | 'did-get-redirect-request'
  | 'dom-ready'
  | 'page-favicon-updated'
  | 'new-window'
  | 'will-navigate'
  | 'did-navigate'
  | 'did-navigate-in-page'
  | 'crashed'
  | 'plugin-crashed'
  | 'destroyed'
  | 'before-input-event'
  | 'devtools-opened'
  | 'devtools-closed'
  | 'devtools-focused'
  | 'certificate-error'
  | 'select-client-certificate'
  | 'login'
  | 'found-in-page'
  | 'media-started-playing'
  | 'media-paused'
  | 'did-change-theme-color'
  | 'update-target-url'
  | 'cursor-changed'
  | 'select-bluetooth-device'
  | 'paint'
  | 'devtools-reload-page'
  | 'will-attach-webview';

type electron$WebContentsListener = (
  event: electron$WebContentsEvents,
  callback: (event: Object, ...args: Array<any>) => void,
) => electron$WebContents;

declare class electron$WebContents {
  on: electron$WebContentsListener,
  once: electron$WebContentsListener,
  loadURL(
    url: string,
    options?: {httpReferrer?: string, userAgent?: string, extraHeaders?: string},
  ): void,
  downloadURL(url: string): void,
  getURL(): string,
  getTitle(): string,
  isDestroyed(): boolean,
  isFocused(): boolean,
  isLoading(): boolean,
  isLoadingMainFrame(): boolean,
  isWaitingForResponse(): boolean,
  stop(): void,
  reload(): void,
  reloadIgnoringCache(): void,
  canGoBack(): boolean,
  canGoForward(): boolean,
  canGoToOffset(offset: number): boolean,
  clearHistory(): void,
  goBack(): void,
  goForward(): void,
  goToIndex(index: number): void,
  goToOffset(index: number): void,
  isCrashed(): boolean,
  setUserAgent(userAgent: string): void,
  getUserAgent(): string,
  insertCSS(css: string): void,
  // Keep `result` as mixed (and not any) to make this unsafe function less so.
  executeJavaScript(code: string, callback: (result: mixed) => void): void,
  executeJavaScript(code: string, userGesture?: boolean, callback?: (result: mixed) => void): void,
  setAudioMuted(muted: boolean): void,
  isAudioMuted(): boolean,
  setZoomFactor(factor: number): void,
  getZoomFactor(callback: (factor: number) => void): void,
  setZoomLevel(level: number): void,
  getZoomLevel(callback: (level: number) => void): void,
  setZoomLevelLimits(minimumLevel: number, maximumLevel: number): void,
  setVisualZoomLevelLimits(minimumLevel: number, maximumLevel: number): void,
  setLayoutZoomLevelLimits(minimumLevel: number, maximumLevel: number): void,
  undo(): void,
  redo(): void,
  cut(): void,
  copy(): void,
  copyImageAt(x: number, y: number): void,
  paste(): void,
  pasteAndMatchStyle(): void,
  delete(): void,
  selectAll(): void,
  unselect(): void,
  replace(text: string): void,
  replaceMisspelling(text: string): void,
  insertText(text: string): void,
  inserfindInPagetText(
    text: string,
    options?: {
      forward?: boolean,
      findNext?: boolean,
      matchCase?: boolean,
      wordStart?: boolean,
      medialCapitalAsWordStart?: boolean,
    },
  ): void,
  stopFindInPage(action: 'clearSelection' | 'keepSelection' | 'activateSelection'): void,
  capturePage(rect: electron$rect, callback: (image: electron$NativeImage) => void): void,
  capturePage(callback: (image: electron$NativeImage) => void): void,
  hasServiceWorker(callback: (result: boolean) => void): void,
  unregisterServiceWorker(callback: (result: boolean) => void): void,
  print(options?: {silent?: boolean, printBackground?: boolean}): void,
  printToPDF(options: {
    marginsType?: number,
    pageSize?: string | { width: number, height: number },
    printBackground?: boolean,
    printSelectionOnly?: boolean,
    landscape?: boolean,
  }, callback: (err: ?mixed, data: ?Buffer) => void): void,
  addWorkSpace(path: string): void,
  removeWorkSpace(path: string): void,
  openDevTools(options?: {mode: 'right' | 'bottom' | 'undocked' | 'detach'}): void,
  closeDevTools(): void,
  isDevToolsOpened(): boolean,
  isDevToolsFocused(): boolean,
  toggleDevTools(): void,
  inspectElement(x: number, y: number): void,
  inspectServiceWorker(): void,
  send(channel: string, ...args: Array<any>): void,
  enableDeviceEmulation(parameters: {
    screenPosition?: 'desktop' | 'mobile',
    screenSize: {width: number, height: number},
    viewPosition?: {x: number, y: number},
    deviceScaleFactor?: number,
    viewSize?: {width: number, height: number},
    fitToView?: boolean,
    offset?: {x: number, y: number},
    scale?: number,
  }): void,
  disableDeviceEmulation(): void,
  sendInputEvent(
    event:
      {
        type: 'keyDown' | 'keyUp' | 'char',
        modifiers?: electron$InputEventModifiers,
        keyCode: string,
      } | {
        type: 'mouseDown' | 'mouseUp' | 'mouseEnter' | 'mouseLeave' | 'contextMenu',
        modifiers?: electron$InputEventModifiers,
        x: number,
        y: number,
        button: 'left' | 'middle' | 'right',
        globalX: number,
        globalY: number,
        movementX: number,
        movementY: number,
        clickCount: number,
      } | {
        type: 'mouseWheel',
        modifiers?: electron$InputEventModifiers,
        x: number,
        y: number,
        button: 'left' | 'middle' | 'right',
        globalX: number,
        globalY: number,
        movementX: number,
        movementY: number,
        clickCount: number,
        deltaX: number,
        deltaY: number,
        wheelTicksX: number,
        wheelTicksY: number,
        accelerationRatioX: number,
        accelerationRatioY: number,
        hasPreciseScrollingDeltas: boolean,
        canScroll: boolean,
      },
  ): void,
  beginFrameSubscription(
    callback: (frameBuffer: Buffer, dirtyRect: electron$rect) => void,
  ): void,
  beginFrameSubscription(
    onlyDirty?: boolean,
    callback: (frameBuffer: Buffer, dirtyRect: electron$rect) => void,
  ): void,
  endFrameSubscription(): void,
  startDrag(item: {file: string, icon: electron$NativeImage}): void,
  savePage(
    fullPath: string,
    saveType: 'HTMLOnly' | 'HTMLComplete' | 'MHTML',
    callback: (error: ?mixed) => void,
  ): void,
  showDefinitionForSelection(): void,
  isOffscreen(): boolean,
  startPainting(): void,
  stopPainting(): void,
  isPainting(): boolean,
  setFrameRate(fps: number): void,
  getFrameRate(): ?number,

  id: number,
  session: electron$session,
  hostWebContents: ?electron$WebContents,
  devToolsWebContents: ?electron$WebContents,
  debugger: ?electron$Debugger,
}

declare class electron$Debugger extends events$EventEmitter {
  attach(protocolVersion?: string): void,
  isAttached(): boolean,
  detach(): void,
  sendCommand(
    method: string,
    callback?: (error: ?mixed, result: ?mixed) => void,
  ): void,
  sendCommand(
    method: string,
    commandParams?: Object,
    callback?: (error: ?mixed, result: ?mixed) => void,
  ): void,
}

type electron$webContents = {
  getAllWebContents(): Array<electron$WebContents>,
  getFocusedWebContents: ?electron$WebContents,
  fromId(id: number): ?electron$WebContents,
};

//------------------------------------------------------------------------------
// Modules for the Renderer Process (Web Page)
//------------------------------------------------------------------------------

/**
 * https://github.com/electron/electron/blob/master/docs/api/desktop-capturer.md
 */

type electron$desktopCapturer = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/ipc-renderer.md
 */

declare class electron$IpcRenderer {
  on(channel: string, callback: (...args: Array<any>) => void): electron$IpcRenderer,
  once(channel: string, callback: (...args: Array<any>) => void): electron$IpcRenderer,
  removeListener(channel: string, callback: (...args: Array<any>) => void): electron$IpcRenderer,
  removeAllListeners(channel?: string): electron$IpcRenderer,
  send(channel: string, ...args: Array<any>): void,
  sendSync(channel: string, ...args: Array<any>): void,
  sendToHost(channel: string, ...args: Array<any>): void,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/remote.md
 */

type electron$remote = {
  // main process built-in modules:
  app: electron$app,
  autoUpdater: electron$autoUpdater,
  BrowserWindow: typeof electron$BrowserWindow,
  contentTracing: electron$contentTracing,
  dialog: electron$dialog,
  globalShortcut: electron$globalShortcut,
  ipcMain: electron$IpcMain,
  Menu: typeof electron$Menu,
  MenuItem: typeof electron$MenuItem,
  powerMonitor: electron$powerMonitor,
  powerSaveBlocker: electron$powerSaveBlocker,
  protocol: electron$protocol,
  session: electron$session,
  electron$Tray: typeof electron$Tray,
  webContents: electron$webContents,
  // methods:
  require(module: string): any,
  getCurrentWindow(): electron$BrowserWindow,
  getCurrentWebContents(): electron$WebContents,
  getGlobal(name: string): ?mixed,
  process: typeof process,
};

/**
 * https://github.com/electron/electron/blob/master/docs/api/web-frame.md
 */

type electron$webFrame = {};

//------------------------------------------------------------------------------
// Modules for Both Processes
//------------------------------------------------------------------------------

/**
 * https://github.com/electron/electron/blob/master/docs/api/clipboard.md
 */

type electron$clipboard = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/crash-reporter.md
 */

type electron$crashReporter = {};

/**
 * https://github.com/electron/electron/blob/master/docs/api/native-image.md
 */

type electron$nativeImage = {
  createEmpty(): electron$NativeImage,
  createFromPath(path: string): electron$NativeImage,
  createFromBuffer(buffer: Buffer, scaleFactor?: number): electron$NativeImage,
  createFromDataURL(dataURL: string): electron$NativeImage,
};

declare class electron$NativeImage {
  toPNG(): Uint8Array,
  toJPEG(quality: number): Uint8Array,
  toBitmap(): Uint8Array,
  toDataURL(): string,
  getNativeHandle(): Uint8Array,
  isEmpty(): boolean,
  getSize(): {width: number, height: number},
  setTemplateImage(option: boolean): void,
  isTemplateImage(): boolean,
  // Deprecated, but Atom is behind - so keep them around.
  toPng(): Uint8Array,
  toJpeg(quality: number): Uint8Array,
  toDataUrl(): string,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/screen.md
 */

type electron$Display = {
  id: number,
  rotation: 0 | 90 | 180 | 270,
  scaleFactor: number,
  touchSupport: 'available' | 'unavailable' | 'unknown',
  bounds: electron$rect,
  size: {height: number, width: number},
  workArea: electron$rect,
  workAreaSize: {height: number, width: number},
};

type electron$DisplayEvents =
    'display-added'
  | 'display-removed'
  | 'display-metrics-changed';

type electron$ScreenListener = (
  event: electron$DisplayEvents,
  callback: (
    event: Object,
    display: electron$Display,
    changedMetrics?: Array<'bounds' | 'workArea' | 'scaleFactor' | 'rotation'>,
  ) => void,
) => electron$Screen;

declare class electron$Screen {
  on: electron$ScreenListener,
  once: electron$ScreenListener,
  removeAllListeners(event?: electron$DisplayEvents): electron$Screen,
  removeListener(event?: electron$DisplayEvents, callback: Function): electron$Screen,
  getCursorScreenPoint(): {x: number, y: number},
  getPrimaryDisplay(): electron$Display,
  getAllDisplays(): Array<electron$Display>,
  getDisplayNearestPoint(point: {x: number, y: number}): electron$Display,
  getDisplayMatching(rect: electron$rect): electron$Display,
}

/**
 * https://github.com/electron/electron/blob/master/docs/api/shell.md
 */

type electron$shell = {
  showItemInFolder(fullPath: string): void,
  openItem(fullPath: string): void,
  openExternal(url: string, options?: {activate: boolean}): void,
  moveItemToTrash(fullPath: string): boolean,
  beep(): void,
  // Windows-only
  writeShortcutLink(
    shortcutPath: string,
    operation?: 'create' | 'update' | 'replace',
    options?: {
      target: string,
      cwd?: string,
      args?: string,
      description?: string,
      icon?: string,
      iconIndex?: number,
      appUserModelId?: string,
    }
  ): void,
  // Windows-only
  readShortcutLink(shortcutPath: string): void,
};


text:
<?xml version='1.0'?>

<policy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="urn:jboss:security-config:5.0" xmlns="urn:jboss:security-config:5.0"
	xmlns:jbxb="urn:jboss:security-config:5.0">
	<application-policy name="modeshape-jcr">
		<authentication>
			<login-module code="org.jboss.security.auth.spi.UsersRolesLoginModule" flag="required">
                <module-option name="usersProperties">security/users.properties</module-option>
                <module-option name="rolesProperties">security/roles.properties</module-option>
				<module-option name="name">1.1</module-option>
				<module-option name="succeed">true</module-option>
				<module-option name="throwEx">false</module-option>
			</login-module>
		</authentication>
	</application-policy>
</policy>


text:
package main

import (
	log "code.google.com/p/log4go"
	"github.com/Terry-Mao/protorpc"
	"math/rand"
)

const (
	PUSH_MAX_BLOCK = 1000
)

type pushArg struct {
	C       *protorpc.Client
	Server  int32
	SubKeys []string
	Msg     []byte
}

var (
	pushChs []chan *pushArg
)

func InitPush() {
	pushChs = make([]chan *pushArg, Conf.PushChan)
	for i := 0; i < Conf.PushChan; i++ {
		pushChs[i] = make(chan *pushArg, Conf.PushChanSize)
		go processPush(pushChs[i])
	}
}

func processPush(ch chan *pushArg) {
	var arg *pushArg
	for {
		arg = <-ch
		mpushComet(arg.C, arg.Server, arg.SubKeys, arg.Msg)
	}
}

func getPushCh() chan *pushArg {
	return pushChs[rand.Int()%Conf.PushChan]
}

// multi-userids push
func mpush(server int32, subkeys []string, msg []byte) {
	c, err := getCometByServerId(server)
	if err != nil {
		log.Error("getCometByServerId(\"%d\") error(%v)", server, err)
		return
	}
	i := 0
	for i = 0; i < len(subkeys)/PUSH_MAX_BLOCK; i++ {
		getPushCh() <- &pushArg{C: c, Server: server, SubKeys: subkeys[i*PUSH_MAX_BLOCK : (i+1)*PUSH_MAX_BLOCK], Msg: msg}
	}
	getPushCh() <- &pushArg{C: c, Server: server, SubKeys: subkeys[i*PUSH_MAX_BLOCK:], Msg: msg}
}

// mssage broadcast
func broadcast(msg []byte) {
	for serverId, c := range cometServiceMap {
		if *c == nil {
			log.Error("broadcast error(%v)", ErrComet)
			return
		}
		// WARN: broadcast called less than mpush, no need a ch for queue
		go broadcastComet(*c, serverId, msg)
	}
}


text:
using SADFM.Data.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SADFM.Infrastructure.Repositories
{
    public interface IFacilityRepository
    {
        List<Provider> GetAll();
        Provider GetDetails(Guid id);
    }
}


text:
//
//  ARKCompany.h
//  Arkio
//
//  Created by Ray Scott on 24/11/2013.
//  Copyright (c) 2013 Alien Hitcher. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#import "ARKEntity.h"

/**
 *  A Company entity in the Data.com service.
 */
@interface ARKCompany : ARKEntity

/**
 *  The unique identifier of a company in Data.com.
 */
@property long companyID;

/**
 *  The name of a company.
 */
@property (nonatomic, strong) NSString *name;

/**
 *  The land-line phone number of a company.
 */
@property (nonatomic, strong) NSString *phone;

/**
 *  The URL of a company's website.
 */
@property (nonatomic, strong) NSURL *website;

/**
 *  The stock symbol for a publically traded company.
 */
@property (nonatomic, strong) NSString *stockSymbol;

/**
 *  Indicates whether a public company's shares are traded on the stock exchange.
 */
@property (nonatomic, strong) NSString *stockExchange;

/**
 *  The user ownership type of a company.
 */
@property (nonatomic, strong) NSString *ownership;

/**
 *  The Fortune 500 rank of a company.
 */
@property (nonatomic) long fortuneRank;

/**
 *  The number of people currently employed by a company.
 */
@property (nonatomic) long employeeCount;

/**
 *  The minimum and maximum range within which the employee count value falls.
 */
@property (nonatomic, strong) NSString *employeeRange;

/**
 *  The annual revenue of a company.
 */
@property (nonatomic, strong) NSString *revenue;

/**
 *  Primary Industry Code.
 */
@property (nonatomic, strong) NSString *industry1;

/**
 *  Secondary Industry Code.
 */
@property (nonatomic, strong) NSString *industry2;

/**
 *  Tertiary Industry Code.
 */
@property (nonatomic, strong) NSString *industry3;

/**
 *  Primary Sub-Industry Code.
 */
@property (nonatomic, strong) NSString *subIndustry1;

/**
 *  Secondary Sub-Industry Code.
 */
@property (nonatomic, strong) NSString *subIndustry2;

/**
 *  Tertiary Sub-Industry Code.
 */
@property (nonatomic, strong) NSString *subIndustry3;

/**
 *  The Standard Industrial Classification System Code for a company.
 */
@property (nonatomic, strong) NSString *sicCode;

/**
 *  Address Line 1.
 */
@property (nonatomic, strong) NSString *address;

/**
 *  City name.
 */
@property (nonatomic, strong) NSString *city;

/**
 *  State name.
 */
@property (nonatomic, strong) NSString *state;

/**
 *  Zip/Postal Code.
 */
@property (nonatomic, strong) NSString *zip;

/**
 *  Country name.
 */
@property (nonatomic, strong) NSString *country;

/**
 *  The number of active contacts for a company.
 */
@property (nonatomic) long activeContacts;

/**
 *  A LinkedIn Profile URL.
 */
@property (nonatomic, strong) NSURL *linkInJigsaw;

/**
 *  Creation date.
 */
@property (nonatomic, strong) NSDate *createdOn;

@end


text:
package com.amazonaws.services.elastictranscoder.model.transform;

import javax.annotation.Generated;

import com.amazonaws.SdkClientException;
import com.amazonaws.services.elastictranscoder.model.*;

import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;

/**
 * HlsContentProtectionMarshaller
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class HlsContentProtectionMarshaller {

    private static final MarshallingInfo<String> METHOD_BINDING = MarshallingInfo.builder(MarshallingType.STRING).marshallLocation(MarshallLocation.PAYLOAD)
            .marshallLocationName("Method").build();
    private static final MarshallingInfo<String> KEY_BINDING = MarshallingInfo.builder(MarshallingType.STRING).marshallLocation(MarshallLocation.PAYLOAD)
            .marshallLocationName("Key").build();
    private static final MarshallingInfo<String> KEYMD5_BINDING = MarshallingInfo.builder(MarshallingType.STRING).marshallLocation(MarshallLocation.PAYLOAD)
            .marshallLocationName("KeyMd5").build();
    private static final MarshallingInfo<String> INITIALIZATIONVECTOR_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("InitializationVector").build();
    private static final MarshallingInfo<String> LICENSEACQUISITIONURL_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("LicenseAcquisitionUrl").build();
    private static final MarshallingInfo<String> KEYSTORAGEPOLICY_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
            .marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("KeyStoragePolicy").build();

    private static final HlsContentProtectionMarshaller instance = new HlsContentProtectionMarshaller();

    public static HlsContentProtectionMarshaller getInstance() {
        return instance;
    }

    /**
     * Marshall the given parameter object.
     */
    public void marshall(HlsContentProtection hlsContentProtection, ProtocolMarshaller protocolMarshaller) {

        if (hlsContentProtection == null) {
            throw new SdkClientException("Invalid argument passed to marshall(...)");
        }

        try {
            protocolMarshaller.marshall(hlsContentProtection.getMethod(), METHOD_BINDING);
            protocolMarshaller.marshall(hlsContentProtection.getKey(), KEY_BINDING);
            protocolMarshaller.marshall(hlsContentProtection.getKeyMd5(), KEYMD5_BINDING);
            protocolMarshaller.marshall(hlsContentProtection.getInitializationVector(), INITIALIZATIONVECTOR_BINDING);
            protocolMarshaller.marshall(hlsContentProtection.getLicenseAcquisitionUrl(), LICENSEACQUISITIONURL_BINDING);
            protocolMarshaller.marshall(hlsContentProtection.getKeyStoragePolicy(), KEYSTORAGEPOLICY_BINDING);
        } catch (Exception e) {
            throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
        }
    }

}


text:
<?php

namespace Nodes\Api\Exceptions;

use Exception;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Nodes\Api\Http\Response;
use Illuminate\Support\Facades\Log;
use Dingo\Api\Contract\Debug\MessageBagErrors;
use Nodes\Database\Exceptions\EntityNotFoundException;
use Nodes\Exceptions\Exception as NodesException;
use Dingo\Api\Exception\Handler as DingoExceptionHandler;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;

/**
 * Class Handler.
 *
 * @see \Dingo\Api\Exception\Handler
 */
class Handler extends DingoExceptionHandler
{
    /**
     * Array of exceptions not to report.
     *
     * @var array
     */
    protected $dontReport = [
        'Nodes\Api\Auth\Exception\InvalidTokenException',
        'Nodes\Api\Auth\Exception\MissingTokenException',
        'Nodes\Api\Auth\Exception\TokenExpiredException',
    ];

    /**
     * Report and log an exception.
     *
     * @author Morten Rugaard <moru@nodes.dk>
     * @author Rasmus Ebbesen <re@nodes.dk>
     *
     * @param  Exception $e
     * @throws Exception
     */
    public function report(Exception $e)
    {
        try {
            if (class_exists('\Nodes\Bugsnag\ServiceProvider')) {
                if (\Nodes\Bugsnag\ServiceProvider::VERSION == '1.0') {
                    if ($e instanceof NodesException && $e->getReport()) {
                        app('nodes.bugsnag')->notifyException($e, $e->getMeta(), $e->getSeverity());
                    } elseif (!$e instanceof NodesException) {
                        app('nodes.bugsnag')->notifyException($e, null, 'error');
                    }
                } elseif (\Nodes\Bugsnag\ServiceProvider::VERSION == '2.0') {
                    if ($e instanceof NodesException && $e->getReport()) {
                        app('nodes.bugsnag')->notifyException($e, function(\Bugsnag\Report $report) use ($e) {
                            $report->setMetaData($e->getMeta(), true);
                            $report->setSeverity($e->getSeverity());
                        });
                    } elseif (!$e instanceof NodesException) {
                        app('nodes.bugsnag')->notifyException($e, function(\Bugsnag\Report $report) {
                            $report->setSeverity('error');
                        });
                    }
                }
            }
        } catch (\Throwable $e) {
            // Do nothing
        }

        Log::error($e);
    }

    /**
     * Handle an exception if it has an existing handler.
     *
     * @author Morten Rugaard <moru@nodes.dk>
     * @author Casper Rasmussen <cr@nodes.dk>
     *
     * @param \Exception $exception
     * @return \Illuminate\Http\Response
     * @throws \Exception
     */
    public function handle(Exception $exception)
    {
        // ModelNotFoundException is thrown when model bind to route does not exist
        if ($exception instanceof ModelNotFoundException) {
            throw new EntityNotFoundException($exception->getMessage());
        }

        // If we are in configured environments, just throw the exception. Useful for unit testing
        if (in_array(app()->environment(), config('nodes.api.errors.throwOnEnvironment', []))) {
            throw $exception;
        }

        $this->report($exception);

        foreach ($this->handlers as $hint => $handler) {
            if (! $exception instanceof $hint) {
                continue;
            }

            if ($response = $handler($exception)) {
                if (! $response instanceof Response) {
                    $response = new Response($response, $this->getExceptionStatusCode($exception));
                }

                return $response;
            }
        }

        return $this->genericResponse($exception);
    }

    /**
     * Handle a generic error response if there is no handler available.
     *
     * @author Morten Rugaard <moru@nodes.dk>
     *
     * @param \Exception $exception
     * @throws \Exception
     * @return \Illuminate\Http\Response
     */
    protected function genericResponse(Exception $exception)
    {
        $replacements = $this->prepareReplacements($exception);

        $response = $this->newResponseArray();

        array_walk_recursive($response, function (&$value, $key) use ($exception, $replacements) {
            if (starts_with($value, ':') && isset($replacements[$value])) {
                $value = $replacements[$value];
            }
        });

        $response = $this->recursivelyRemoveEmptyReplacements($response);

        return new Response($response, $this->getExceptionStatusCode($exception), $this->getHeaders($exception));
    }

    /**
     * Prepare the replacements array by gathering the keys and values.
     *
     * @author Morten Rugaard <moru@nodes.dk>
     *
     * @param \Exception $exception
     * @return array
     */
    protected function prepareReplacements(Exception $exception)
    {
        // Retrieve status code of exception
        $statusCode = $this->getStatusCode($exception);

        // Retrieve message of exception
        //
        // If the exception does not have a message,
        // we'll fallback to a message of the status code and status message.
        if (! $message = $exception->getMessage()) {
            // Response::$statusTexts does not contain custom codes - default to empty
            $text = isset(Response::$statusTexts[$statusCode]) ? Response::$statusTexts[$statusCode] : 'No message was set in exception';
            $message = sprintf('%d: %s', $statusCode, $text);
        }

        // Base replacements
        $replacements = [
            ':message' => $message,
            // default status code to 500
            ':code' => $exception->getCode() ?: 500,
        ];

        // If exception contains a message bag of errors
        // we'll add them to the replacements array
        if (($exception instanceof NodesException || $exception instanceof MessageBagErrors) && $exception->hasErrors()) {
            $replacements[':errors'] = $exception->getErrors();
        }

        // If exception contains local message
        if ($exception instanceof NodesException && $exception->getLocaleMessage()){
            $replacements[':locale_message'] = $exception->getLocaleMessage();
        }

        // If we're running in debug mode,
        // we'll add much more detailed information
        // extracted from the exception.
        if ($this->runningInDebugMode()) {
            $replacements[':debug'] = [
                'class' => get_class($exception),
                'file' => $exception->getFile(),
                'line' => $exception->getLine(),
                'trace' => explode("\n", $exception->getTraceAsString()),
            ];
        }

        return array_merge($replacements, $this->replacements);
    }

    /**
     * Get the exception status code.
     *
     * @author Morten Rugaard <moru@nodes.dk>
     *
     * @param  \Exception $exception
     * @param  int    $defaultStatusCode
     * @return int|array
     */
    protected function getExceptionStatusCode(Exception $exception, $defaultStatusCode = 500)
    {
        if ($exception instanceof NodesException) {
            return [
                $exception->getStatusCode(),
                $exception->getStatusMessage(),
            ];
        } elseif ($exception instanceof HttpExceptionInterface) {
            return $exception->getStatusCode();
        } else {
            return $defaultStatusCode;
        }
    }
}


text:
<?php

/**
 * OpenID class, controls interfacing and communications for openid auth
 */
class OpenID
{
	/**
	 * Defined in OpenID spec.
	 */
	protected $p = '155172898181473697471232257763715539915724801966915404479707795314057629378541917580651227423698188993727816152646631438561595825688188889951272158842675419950341258706556549803580104870537681476726513255747040765857479291291572334510643245094715007229621094194349783925984760375594985848253359305585439638443';
	protected $g = '2';

	/**
	 * Validate the supplied OpenID, redirects to the IDP server
	 *
	 * What it does:
	 *
	 * - Openid_uri is the URI given by the user
	 * - Validates the URI and changes it to a fully canonical URL
	 * - Determines the IDP server and delegation
	 * - Optional array of fields to restore when validation complete.
	 * - Redirects the user to the IDP for validation
	 *
	 * @param string $openid_uri
	 * @param bool $return = false
	 * @param mixed[]|null $save_fields = array()
	 * @param string|null $return_action = null
	 * @return string
	 * @throws Elk_Exception
	 */
	public function validate($openid_uri, $return = false, $save_fields = array(), $return_action = null)
	{
		global $scripturl, $modSettings;

		$openid_url = $this->canonize($openid_uri);
		$response_data = $this->getServerInfo($openid_url);

		// We can't do anything without the proper response data.
		if ($response_data === false || empty($response_data['provider']))
			return 'no_data';

		// Is there an existing association?
		if (($assoc = $this->getAssociation($response_data['provider'])) === null)
			$assoc = $this->makeAssociation($response_data['provider']);

		// Include file for member existence
		require_once(SUBSDIR . '/Members.subs.php');

		// Before we go wherever it is we are going, store the GET and POST data, because it might be useful when we get back.
		$request_time = time();

		// Just in case they are doing something else at this time.
		while (isset($_SESSION['openid']['saved_data'][$request_time]))
			$request_time = md5($request_time);

		$_SESSION['openid']['saved_data'][$request_time] = array(
			'get' => $_GET,
			'post' => $_POST,
			'openid_uri' => $openid_url,
			'cookieTime' => $modSettings['cookieTime'],
		);

		// Set identity and claimed id to match the specs.
		$openid_identity = 'http://specs.openid.net/auth/2.0/identifier_select';
		$openid_claimedid = $openid_identity;

		// OpenID url an server response equal?
		if ($openid_url != $response_data['server'])
		{
			$openid_identity = urlencode(empty($response_data['delegate']) ? $openid_url : $response_data['delegate']);
			if (strpos($openid_identity, 'https') === 0)
				$openid_claimedid = str_replace('http://', 'https://', $openid_url);
			else
				$openid_claimedid = $openid_url;
		}

		// Prepare parameters for the OpenID setup.
		$parameters = array(
			'openid.mode=checkid_setup',
			'openid.realm=' . $scripturl,
			'openid.ns=http://specs.openid.net/auth/2.0',
			'openid.identity=' . $openid_identity,
			'openid.claimed_id=' . $openid_claimedid,
			'openid.assoc_handle=' . urlencode($assoc['handle']),
			'openid.return_to=' . urlencode($scripturl . '?action=openidreturn&sa=' . (!empty($return_action) ? $return_action : $_REQUEST['action']) . '&t=' . $request_time . (!empty($save_fields) ? '&sf=' . base64_encode(json_encode($save_fields)) : '')),
			'openid.sreg.required=email',
		);

		// If they are logging in but don't yet have an account or they are registering, let's request some additional information
		if (($_REQUEST['action'] == 'login2' && !memberExists($openid_url)) || $_REQUEST['action'] == 'register')
			$parameters[] = 'openid.sreg.optional=nickname,dob';

		$redir_url = $response_data['server'] . '?' . implode('&', $parameters);

		if ($return)
			return $redir_url;
		else
			redirectexit($redir_url);
	}

	/**
	 * Revalidate a user using OpenID.
	 *
	 * - Note that this function will not return when authentication is required.
	 *
	 * @return boolean|null
	 * @throws Elk_Exception
	 */
	public function revalidate()
	{
		global $user_settings;

		if (isset($_SESSION['openid_revalidate_time']) && $_SESSION['openid_revalidate_time'] > time() - 60)
		{
			unset($_SESSION['openid_revalidate_time']);
			return true;
		}
		else
			$this->validate($user_settings['openid_uri'], false, null, 'revalidate');

		// We shouldn't get here.
		trigger_error('Hacking attempt...', E_USER_ERROR);
	}

	/**
	 * Retrieve an existing, not expired, association if there is any.
	 *
	 * @param string $server
	 * @param string|null $handle = null
	 * @param bool $no_delete = false
	 * @return array
	 */
	public function getAssociation($server, $handle = null, $no_delete = false)
	{
		$db = database();

		if (!$no_delete)
		{
			// Delete the already expired associations.
			$db->query('openid_delete_assoc_old', '
				DELETE FROM {db_prefix}openid_assoc
				WHERE expires <= {int:current_time}',
				array(
					'current_time' => time(),
				)
			);
		}

		// Get the association that has the longest lifetime from now.
		$request = $db->query('openid_select_assoc', '
			SELECT server_url, handle, secret, issued, expires, assoc_type
			FROM {db_prefix}openid_assoc
			WHERE (server_url = {string:https_server_url} OR server_url = {string:http_server_url})
			' . ($handle === null ? '' : '
				AND handle = {string:handle}') . '
			ORDER BY expires DESC',
			array(
				'http_server_url' => strtr($server, array('https://' => 'http://')),
				'https_server_url' => strtr($server, array('http://' => 'https://')),
				'handle' => $handle,
			)
		);

		if ($db->num_rows($request) == 0)
			return null;

		$return = $db->fetch_assoc($request);
		$return['server_url'] = $server;
		$db->free_result($request);

		return $return;
	}

	/**
	 * Create and store an association to the given server.
	 *
	 * @param string $server
	 *
	 * @return array
	 * @throws Elk_Exception openid_server_bad_response
	 */
	public function makeAssociation($server)
	{
		$db = database();

		$parameters = array(
			'openid.mode=associate',
			'openid.ns=http://specs.openid.net/auth/2.0',
		);

		// We'll need to get our keys for the Diffie-Hellman key exchange.
		$dh_keys = $this->setup_DH();

		// If we don't support DH we'll have to see if the provider will accept no encryption.
		if ($dh_keys === false)
			$parameters[] = 'openid.session_type=';
		else
		{
			$parameters[] = 'openid.session_type=DH-SHA1';
			$parameters[] = 'openid.dh_consumer_public=' . urlencode(base64_encode(long_to_binary($dh_keys['public'])));
			$parameters[] = 'openid.assoc_type=HMAC-SHA1';
		}

		// The data to post to the server.
		$post_data = implode('&', $parameters);
		$data = fetch_web_data($server, $post_data);

		// Parse the data given.
		preg_match_all('~^([^:]+):(.+)$~m', $data, $matches);
		$assoc_data = array();

		foreach ($matches[1] as $key => $match)
			$assoc_data[$match] = $matches[2][$key];

		if (!isset($assoc_data['assoc_type']) || (empty($assoc_data['mac_key']) && empty($assoc_data['enc_mac_key'])))
			throw new Elk_Exception('openid_server_bad_response');

		// Clean things up a bit.
		$handle = isset($assoc_data['assoc_handle']) ? $assoc_data['assoc_handle'] : '';
		$issued = time();
		$expires = $issued + min((int) $assoc_data['expires_in'], 60);
		$assoc_type = isset($assoc_data['assoc_type']) ? $assoc_data['assoc_type'] : '';

		// @todo Is this really needed?
		foreach (array('dh_server_public', 'enc_mac_key') as $key)
			if (isset($assoc_data[$key]))
				$assoc_data[$key] = str_replace(' ', '+', $assoc_data[$key]);

		// Figure out the Diffie-Hellman secret.
		if (!empty($assoc_data['enc_mac_key']))
		{
			$dh_secret = bcpowmod(binary_to_long(base64_decode($assoc_data['dh_server_public'])), $dh_keys['private'], $this->p);
			$secret = base64_encode(binary_xor(sha1(long_to_binary($dh_secret), true), base64_decode($assoc_data['enc_mac_key'])));
		}
		else
			$secret = $assoc_data['mac_key'];

		// Store the data
		$db->insert('replace',
			'{db_prefix}openid_assoc',
			array('server_url' => 'string', 'handle' => 'string', 'secret' => 'string', 'issued' => 'int', 'expires' => 'int', 'assoc_type' => 'string'),
			array($server, $handle, $secret, $issued, $expires, $assoc_type),
			array('server_url', 'handle')
		);

		return array(
			'server' => $server,
			'handle' => $assoc_data['assoc_handle'],
			'secret' => $secret,
			'issued' => $issued,
			'expires' => $expires,
			'assoc_type' => $assoc_data['assoc_type'],
		);
	}

	/**
	 * Delete an existing association from the database.
	 *
	 * @param string $handle
	 */
	public function removeAssociation($handle)
	{
		$db = database();

		$db->query('openid_remove_association', '
			DELETE FROM {db_prefix}openid_assoc
			WHERE handle = {string:handle}',
			array(
				'handle' => $handle,
			)
		);
	}

	/**
	 * Fix the URI to a canonical form
	 *
	 * @param string $uri
	 */
	public function canonize($uri)
	{
		// @todo Add in discovery.

		$uri = addProtocol($uri, array('http://', 'https://'));

		// Strip http:// and https:// and if there is no / in what is left, add one
		if (strpos(strtr($uri, array('http://' => '', 'https://' => '')), '/') === false)
			$uri .= '/';

		return $uri;
	}

	/**
	 * Prepare for a Diffie-Hellman key exchange.
	 *
	 * @param bool $regenerate = false
	 * @return string return false on failure or an array() on success
	 * @throws Elk_Exception
	 */
	public function setup_DH($regenerate = false)
	{
		// First off, do we have BC Math available?
		if (!function_exists('bcpow'))
			return false;

		// Make sure the scale is set.
		bcscale(0);

		return $this->get_keys($regenerate);
	}

	/**
	 * Retrieve DH keys from the store.
	 *
	 * - It generates them if they're not stored or $regenerate parameter is true.
	 *
	 * @param bool $regenerate
	 * @throws Elk_Exception
	 */
	public function get_keys($regenerate)
	{
		global $modSettings;

		// Ok lets take the easy way out, are their any keys already defined for us? They are changed in the daily maintenance scheduled task.
		if (!empty($modSettings['dh_keys']) && !$regenerate)
		{
			// Sweeeet!
			list ($public, $private) = explode("\n", $modSettings['dh_keys']);
			return array(
				'public' => base64_decode($public),
				'private' => base64_decode($private),
			);
		}

		// Dang it, now I have to do math.  And it's not just ordinary math, its the evil big integer math.
		// This will take a few seconds.
		$private = $this->generate_private_key();
		$public = bcpowmod($this->g, $private, $this->p);

		// Now that we did all that work, lets save it so we don't have to keep doing it.
		$keys = array('dh_keys' => base64_encode($public) . "\n" . base64_encode($private));
		updateSettings($keys);

		return array(
			'public' => $public,
			'private' => $private,
		);
	}

	/**
	 * Generate private key
	 *
	 * @return string
	 * @throws Elk_Exception
	 */
	public function generate_private_key()
	{
		static $cache = array();

		$byte_string = long_to_binary($this->p);

		if (isset($cache[$byte_string]))
			list ($dup, $num_bytes) = $cache[$byte_string];
		else
		{
			$num_bytes = strlen($byte_string) - ($byte_string[0] == "\x00" ? 1 : 0);

			$max_rand = bcpow(256, $num_bytes);

			$dup = bcmod($max_rand, $num_bytes);

			$cache[$byte_string] = array($dup, $num_bytes);
		}

		do
		{
			$str = '';
			for ($i = 0; $i < $num_bytes; $i += 4)
				$str .= pack('L', mt_rand());

			$bytes = "\x00" . $str;

			$num = binary_to_long($bytes);
		} while (bccomp($num, $dup) < 0);

		return bcadd(bcmod($num, $this->p), 1);
	}

	/**
	 * Retrieve server information.
	 *
	 * @param string $openid_url
	 *
	 * @return array|bool
	 * @throws Elk_Exception openid_server_bad_response
	 */
	public function getServerInfo($openid_url)
	{
		require_once(SUBSDIR . '/Package.subs.php');

		// Get the html and parse it for the openid variable which will tell us where to go.
		$webdata = fetch_web_data($openid_url);

		if (empty($webdata))
			return false;

		$response_data = array();

		// dirty, but .. Yadis response? Let's get the <URI>
		preg_match('~<URI.*?>(.*)</URI>~', $webdata, $uri);
		if (!empty($uri))
		{
			$response_data['provider'] = $uri[1];
			$response_data['server'] = $uri[1];
			return $response_data;
		}

		// Some OpenID servers have strange but still valid HTML which makes our job hard.
		if (preg_match_all('~<link([\s\S]*?)/?>~i', $webdata, $link_matches) == 0)
			throw new Elk_Exception('openid_server_bad_response');

		foreach ($link_matches[1] as $link_match)
		{
			if (preg_match('~rel="([\s\S]*?)"~i', $link_match, $rel_match) == 0 || preg_match('~href="([\s\S]*?)"~i', $link_match, $href_match) == 0)
				continue;

			$rels = preg_split('~\s+~', $rel_match[1]);
			foreach ($rels as $rel)
				if (preg_match('~openid2?\.(server|delegate|provider)~i', $rel, $match) != 0)
					$response_data[$match[1]] = $href_match[1];
		}

		if (empty($response_data['provider']))
			$response_data['server'] = $openid_url;
		else
			$response_data['server'] = $response_data['provider'];

		return $response_data;
	}
}

/**
 * Given a binary string, returns the binary string converted to a long number.
 *
 * @param string $str
 * @return string
 */
function binary_to_long($str)
{
	$bytes = array_merge(unpack('C*', $str));

	$n = 0;

	foreach ($bytes as $byte)
	{
		$n = bcmul($n, 256);
		$n = bcadd($n, $byte);
	}

	return $n;
}

/**
 * Given a long integer, returns the number converted to a binary
 * string.
 *
 * This function accepts long integer values of arbitrary
 * magnitude.
 *
 * @param string $value
 *
 * @return string
 * @throws Elk_Exception Only non-negative integers allowed
 */
function long_to_binary($value)
{
	$cmp = bccomp($value, 0);
	if ($cmp < 0)
		throw new Elk_Exception('Only non-negative integers allowed.');

	if ($cmp == 0)
		return "\x00";

	$bytes = array();

	while (bccomp($value, 0) > 0)
	{
		array_unshift($bytes, bcmod($value, 256));
		$value = bcdiv($value, 256);
	}

	if (!empty($bytes) && ($bytes[0] > 127))
		array_unshift($bytes, 0);

	$return = '';
	foreach ($bytes as $byte)
		$return .= pack('C', $byte);

	return $return;
}

/**
 * Performs an exclusive or (^ bitwise operator) character for character on two stings.
 *
 * - The result of the biwise operator is 1 if and only if both bits differ.
 *
 * Returns a binary string representing the per character position comparison results.
 *
 * @param int $num1
 * @param int $num2
 */
function binary_xor($num1, $num2)
{
	$return = '';

	$str_len = strlen($num2);
	for ($i = 0; $i < $str_len; $i++)
		$return .= $num1[$i] ^ $num2[$i];

	return $return;
}

/**
 * Retrieve a member settings based on the claimed id
 *
 * @param string $claimed_id the claimed id
 *
 * @return array the member settings
 */
function memberByOpenID($claimed_id)
{
	$db = database();

	$result = $db->query('', '
		SELECT passwd, id_member, id_group, lngfile, is_activated, email_address, additional_groups, member_name, password_salt,
			openid_uri
		FROM {db_prefix}members
		WHERE openid_uri = {string:openid_uri}',
		array(
			'openid_uri' => $claimed_id,
		)
	);

	$member_found = $db->fetch_assoc($result);
	$db->free_result($result);

	return $member_found;
}


text:
sbt clean

sbt "akkaJsActorJS/compile"

sbt ";++2.12.10;akkaJsActorJS/publishSigned;akkaJsActorStreamJS/publishSigned;akkaJsActorStreamTypedJS/publishSigned;akkaJsActorTypedJS/publishSigned;akkaJsStreamTestkitJS/publishSigned;akkaJsTestkitJS/publishSigned;akkaJsTypedTestkitJS/publishSigned"

sbt ";++2.13.1;akkaJsActorJS/publishSigned;akkaJsActorStreamJS/publishSigned;akkaJsActorStreamTypedJS/publishSigned;akkaJsActorTypedJS/publishSigned;akkaJsStreamTestkitJS/publishSigned;akkaJsTestkitJS/publishSigned;akkaJsTypedTestkitJS/publishSigned"

sbt sonatypeReleaseAll


text:
package org.elasticsearch.percolator;

import org.elasticsearch.action.support.IndicesOptions;
import org.elasticsearch.client.node.NodeClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.rest.BaseRestHandler;
import org.elasticsearch.rest.RestController;
import org.elasticsearch.rest.RestRequest;
import org.elasticsearch.rest.action.RestToXContentListener;

import java.io.IOException;

import static org.elasticsearch.rest.RestRequest.Method.GET;
import static org.elasticsearch.rest.RestRequest.Method.POST;

@Deprecated
public class RestMultiPercolateAction extends BaseRestHandler {

    private final boolean allowExplicitIndex;

    @Inject
    public RestMultiPercolateAction(Settings settings, RestController controller) {
        super(settings);
        controller.registerHandler(POST, "/_mpercolate", this);
        controller.registerHandler(POST, "/{index}/_mpercolate", this);
        controller.registerHandler(POST, "/{index}/{type}/_mpercolate", this);

        controller.registerHandler(GET, "/_mpercolate", this);
        controller.registerHandler(GET, "/{index}/_mpercolate", this);
        controller.registerHandler(GET, "/{index}/{type}/_mpercolate", this);

        this.allowExplicitIndex = MULTI_ALLOW_EXPLICIT_INDEX.get(settings);
    }

    @Override
    public RestChannelConsumer prepareRequest(final RestRequest restRequest, final NodeClient client) throws IOException {
        MultiPercolateRequest multiPercolateRequest = new MultiPercolateRequest();
        multiPercolateRequest.indicesOptions(IndicesOptions.fromRequest(restRequest, multiPercolateRequest.indicesOptions()));
        multiPercolateRequest.indices(Strings.splitStringByCommaToArray(restRequest.param("index")));
        multiPercolateRequest.documentType(restRequest.param("type"));
        multiPercolateRequest.add(restRequest.contentOrSourceParam().v2(), allowExplicitIndex);
        return channel -> client.execute(MultiPercolateAction.INSTANCE, multiPercolateRequest, new RestToXContentListener<>(channel));
    }

    @Override
    public boolean supportsContentStream() {
        return true;
    }
}


text:
'use strict';

const _poll = _system.binding('poll');

function poll(pfds, timeout) {
    if (timeout == null) {
        timeout = null;
    } else {
        timeout = parseFloat(timeout);
        if (isNaN(timeout) || timeout < 0) {
            throw new TypeError('timeout must be null or a positive number')
        }
    }
    return _poll.poll(pfds, timeout);
}

exports.poll = poll;

// extract constants
for (var k in _poll.c) {
    var val = _poll.c[k];
    exports[k] = val;
}


text:
package com.google.devtools.intellij.protoeditor.ide.settings;

import com.google.devtools.intellij.protoeditor.ide.settings.PbProjectSettings.ImportPathEntry;
import com.google.devtools.intellij.protoeditor.lang.resolve.FileResolveProvider;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileManager;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.psi.search.GlobalSearchScopesCore;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

/** {@link FileResolveProvider} implementation that uses settings from {@link PbProjectSettings}. */
public class SettingsFileResolveProvider implements FileResolveProvider {

  private PbProjectSettings staticSettings;

  /** No-op constructor. Settings will be resolved by looking up the PbProjectSettings service. */
  public SettingsFileResolveProvider() {
    this.staticSettings = null;
  }

  /**
   * Constructs a SettingsFileResolveProvider backed by the static {@link PbProjectSettings} object.
   * Updates to the configuration in the {@link PbProjectSettings} service will not be reflected.
   * This constructor can be used to preview the effects of settings that have not yet been
   * persisted.
   *
   * @param staticSettings A {@link PbProjectSettings} object to use.
   */
  public SettingsFileResolveProvider(PbProjectSettings staticSettings) {
    this.staticSettings = staticSettings;
  }

  @Nullable
  @Override
  public VirtualFile findFile(@NotNull String path, @NotNull Project project) {
    PbProjectSettings settings = getSettings(project);
    for (ImportPathEntry entry : settings.getImportPathEntries()) {
      String prefix = normalizePath(entry.getPrefix());
      if (!path.startsWith(prefix)) {
        continue;
      }

      VirtualFile location = VirtualFileManager.getInstance().findFileByUrl(entry.getLocation());
      if (location == null) {
        continue;
      }
      String unprefixedPath = path.substring(prefix.length());
      VirtualFile imported = location.findFileByRelativePath(unprefixedPath);
      if (PROTO_FILTER.accept(imported)) {
        return imported;
      }
    }
    return null;
  }

  @NotNull
  @Override
  public Collection<ChildEntry> getChildEntries(@NotNull String path, @NotNull Project project) {
    PbProjectSettings settings = getSettings(project);
    Set<ChildEntry> results = new HashSet<>();
    for (ImportPathEntry entry : settings.getImportPathEntries()) {
      String prefix = normalizePath(entry.getPrefix());
      path = normalizePath(path);

      if (prefix.startsWith(path) && !prefix.equals(path)) {
        String nextPrefixComponent = prefix.substring(path.length()).split("/")[0];
        results.add(ChildEntry.directory(nextPrefixComponent));
      } else if (path.startsWith(prefix)) {
        // defer to the backing filesystem.
        VirtualFile location = VirtualFileManager.getInstance().findFileByUrl(entry.getLocation());
        if (location == null) {
          continue;
        }

        String unprefixedPath = path.substring(prefix.length());
        VirtualFile pathFile = location.findFileByRelativePath(unprefixedPath);
        if (pathFile == null) {
          continue;
        }

        VirtualFile[] children = pathFile.getChildren();
        if (children == null) {
          continue;
        }

        for (VirtualFile child : children) {
          if (PROTO_AND_DIRECTORY_FILTER.accept(child)) {
            results.add(new ChildEntry(child.getName(), child.isDirectory()));
          }
        }
      }
    }
    return results;
  }

  @Nullable
  @Override
  public VirtualFile getDescriptorFile(@NotNull Project project) {
    PbProjectSettings settings = getSettings(project);
    String descriptorPath = settings.getDescriptorPath();
    if (descriptorPath != null) {
      return findFile(descriptorPath, project);
    }
    return null;
  }

  @NotNull
  @Override
  public GlobalSearchScope getSearchScope(@NotNull Project project) {
    PbProjectSettings settings = getSettings(project);
    VirtualFile[] roots =
        settings
            .getImportPathEntries()
            .stream()
            .map(ImportPathEntry::getLocation)
            .map(VirtualFileManager.getInstance()::findFileByUrl)
            .filter(file -> file != null)
            .toArray(VirtualFile[]::new);
    return GlobalSearchScopesCore.directoriesScope(project, /* withSubDirectories= */ true, roots);
  }

  @NotNull
  private PbProjectSettings getSettings(Project project) {
    if (staticSettings != null) {
      return staticSettings;
    }
    return PbProjectSettings.getInstance(project);
  }

  /** For the given path, return a non-null string that, if not empty, ends with a slash. */
  private String normalizePath(@Nullable String path) {
    // TODO(volkman): better way to handle multi-platform differences with filesystem separators?
    if (path == null) {
      return "";
    }
    if (!path.isEmpty() && !path.endsWith("/")) {
      return path + "/";
    }
    return path;
  }
}


text:
using LightBDD.Core.Metadata;
using LightBDD.Core.Results.Parameters;

namespace LightBDD.Framework.Results.Implementation
{
    internal class InlineParameterDetails : IInlineParameterDetails
    {
        public InlineParameterDetails(string expectation, string value, ParameterVerificationStatus verificationStatus, string message)
        {
            Expectation = expectation;
            Value = value;
            VerificationStatus = verificationStatus;
            VerificationMessage = message;
        }

        public string VerificationMessage { get; }
        public ParameterVerificationStatus VerificationStatus { get; }
        public string Value { get; }
        public string Expectation { get; }
    }
}


text:
describe RuboCop::Cop::Style::MinMax, :config do
  subject(:cop) { described_class.new(config) }

  context 'with an array literal containing calls to `#min` and `#max`' do
    context 'when the expression stands alone' do
      it 'registers an offense if the receivers match' do
        expect_offense(<<-RUBY.strip_indent)
          [foo.min, foo.max]
          ^^^^^^^^^^^^^^^^^^ Use `foo.minmax` instead of `[foo.min, foo.max]`.
        RUBY
      end

      it 'does not register an offense if the receivers do not match' do
        expect_no_offenses(<<-RUBY.strip_indent)
          [foo.min, bar.max]
        RUBY
      end

      it 'does not register an offense if there are additional elements' do
        expect_no_offenses(<<-RUBY.strip_indent)
          [foo.min, foo.baz, foo.max]
        RUBY
      end

      it 'auto-corrects an offense to use `#minmax`' do
        corrected = autocorrect_source(<<-RUBY.strip_indent)
          [foo.bar.min, foo.bar.max]
        RUBY

        expect(corrected).to eq(<<-RUBY.strip_indent)
          foo.bar.minmax
        RUBY
      end
    end

    context 'when the expression is used in a parallel assignment' do
      it 'registers an offense if the receivers match' do
        expect_offense(<<-RUBY.strip_indent)
          bar = foo.min, foo.max
                ^^^^^^^^^^^^^^^^ Use `foo.minmax` instead of `foo.min, foo.max`.
        RUBY
      end

      it 'does not register an offense if the receivers do not match' do
        expect_no_offenses(<<-RUBY.strip_indent)
          baz = foo.min, bar.max
        RUBY
      end

      it 'does not register an offense if there are additional elements' do
        expect_no_offenses(<<-RUBY.strip_indent)
          bar = foo.min, foo.baz, foo.max
        RUBY
      end

      it 'auto-corrects an offense to use `#minmax`' do
        corrected = autocorrect_source(<<-RUBY.strip_indent)
          baz = foo.bar.min, foo.bar.max
        RUBY

        expect(corrected).to eq(<<-RUBY.strip_indent)
          baz = foo.bar.minmax
        RUBY
      end
    end

    context 'when the expression is used as a return value' do
      it 'registers an offense if the receivers match' do
        expect_offense(<<-RUBY.strip_indent)
          return foo.min, foo.max
                 ^^^^^^^^^^^^^^^^ Use `foo.minmax` instead of `foo.min, foo.max`.
        RUBY
      end

      it 'does not register an offense if the receivers do not match' do
        expect_no_offenses(<<-RUBY.strip_indent)
          return foo.min, bar.max
        RUBY
      end

      it 'does not register an offense if there are additional elements' do
        expect_no_offenses(<<-RUBY.strip_indent)
          return foo.min, foo.baz, foo.max
        RUBY
      end

      it 'auto-corrects an offense to use `#minmax`' do
        corrected = autocorrect_source(<<-RUBY.strip_indent)
          return foo.bar.min, foo.bar.max
        RUBY

        expect(corrected).to eq(<<-RUBY.strip_indent)
          return foo.bar.minmax
        RUBY
      end
    end
  end
end


text:
using IS24RestApi.Offer.RealEstates;
using RestSharp;
using RestSharp.Deserializers;
using RestSharp.Serializers;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using Xunit;

namespace IS24RestApi.Tests
{
    public class SerializationTests
    {
        [Fact]
        public void CanSerializeAndDeserializeAllExampleXmlFiles()
        {
            Test<RealEstate>("apartmentBuy");
            Test<RealEstate>("apartmentRent");
            Test<RealEstate>("assistedLiving");
            Test<RealEstate>("compulsoryAuction");
            Test<RealEstate>("garageBuy");
            Test<RealEstate>("garageRent");
            Test<RealEstate>("gastronomy");
            Test<RealEstate>("houseBuy");
            Test<RealEstate>("houseRent");
            Test<RealEstate>("houseType");
            Test<RealEstate>("industry");
            Test<RealEstate>("investment");
            Test<RealEstate>("livingBuySite");
            Test<RealEstate>("livingRentSite");
            Test<RealEstate>("office");
            Test<RealEstate>("seniorCare");
            Test<RealEstate>("shortTermAccommodation");
            Test<RealEstate>("specialPurpose");
            Test<RealEstate>("store");
            Test<RealEstate>("tradeSite");
            Test<RealEstate>("flatShareRoom");
        }

        void Test<T>(string file)
        {
            var xmlSerializer = new BaseXmlSerializer();
            var xmlDeserializer = new BaseXmlDeserializer();

            foreach (var suffix in new[] { "min", "max" })
            {
                var xml = File.ReadAllText($@"..\..\..\xml\{file}_{suffix}.xml");

                var deserializedObject = xmlDeserializer.Deserialize<T>(new RestResponse { Content = xml });

                var serializedXml = xmlSerializer.Serialize(deserializedObject);
                var deserializedXml = xmlDeserializer.Deserialize<T>(new RestResponse { Content = serializedXml });
                AssertEx.Equal(deserializedObject, deserializedXml);
            }
        }

        [Fact]
        public void BaseXmlSerializer_CanSerializeToBaseClass()
        {
            var re = new ApartmentRent { Title = "Test" };
            var xml = new BaseXmlSerializer().Serialize(re, typeof(RealEstate));
            var xElement = XElement.Parse(xml);

            Assert.Equal("realEstate", xElement.Name.LocalName);
        }
    }
}


text:
#include "cr_string.h"
#include "cr_environment.h"
#include "cr_error.h"
#include "cr_mem.h"
#include "feedbackspu.h"

#include <stdio.h>
#ifndef WINDOWS
#include <unistd.h>
#endif

static void __setDefaults( void )
{
	feedback_spu.render_mode = GL_RENDER;
}

static void set_default_viewport( void *foo, const char *response )
{
   sscanf( response, "%d", &(feedback_spu.default_viewport) );
}

/* option, type, nr, default, min, max, title, callback
 */
SPUOptions feedbackSPUOptions[] = {

   { "default_viewport", CR_BOOL, 1, "0", "0", "1",
     "Return default viewport parameters", (SPUOptionCB)set_default_viewport },

   { NULL, CR_BOOL, 0, NULL, NULL, NULL, NULL, NULL },

};

void feedbackspuGatherConfiguration( void )
{
	__setDefaults();
}


text:
html {
	/* height: 100%; */
}
body {
  box-sizing: border-box;
  margin: 0;
  font-family: "Raleway","Alegreya Sans",sans-serif;
  font-size: 1em;
  text-decoration: none;
  /* height: 100%; */
  width: 100%;
  font-weight: normal;
}
div, ol, ul, li, a, img, form, label, input, iframe, button, textarea {
  position: relative;
  display: inline-block;
  box-sizing: border-box;
  margin: 0 0 0 0;
  padding: 0 0 0 0;
  background-position: center;
  background-size: cover;
  border: none;
  list-style: none;
  font-family: "Raleway","Alegreya Sans",sans-serif;
}

/*colors*/

.checkboxUI0,
.input-text-1,
.border-bottom-2,
.border-color-3 {
  border-color: #9aad90; /* chrome paisley light */
}
.border-color-4 {
  border-color: #64765b;  /* chrome paisley leaf */
}
.border-color-5 {
  border-color: #504a43;  /* chrome paisley shadow */
}
[type=checkbox]:checked + .checkboxUI0::after,
.border-color-6 {
  border-color: #05535b;   /* chrome paisley bluish */
}
.border-1,
.border-bottom-1,
.border-color-7 {
  border-color: #e6dec7;  /* chrome paisley tan */
  border-color: #f2eee3;  /* chrome paisley tan half white */
}
.clickable4:not([href]),
.fill-1 {
  fill: #fff;
}
svg > path.forecolor,
.fill-2 {
  fill: #9aad90; /* chrome paisley light */
}
.clickable4[href]:hover,
.fill-3 {
  fill: #9aad90; /* chrome paisley light */
}
.fill-4 {
  fill: #9aad90; /* chrome paisley light */
  fill: #504a43;  /* chrome paisley shadow */
  fill: #64765b;  /* chrome paisley leaf */
}
.clickable4,
.fill-5 {
  fill: #9aad90; /* chrome paisley light */
  fill: #504a43;  /* chrome paisley shadow */
}
.drag-drop-1.gu-mirror,
.clickable3,
.input-text-1,
.text3,
.bg-none {
  background: none !important;
}
.bg-color-1 {
  background-color: #504a43;  /* chrome paisley shadow */
}
.text4,
.clickable1,
button,
input[type=submit],
.clickable1,
.bg-color-2 {
  background-color: #64765b;  /* chrome paisley leaf */
}
/* the seletion selector breaks firefox for the other selectors, so it goes by itself */
.input-text-1::selection {
  background-color: #9aad90; /* chrome paisley light */
  /*
   * Background pattern from Toptal Subtle Patterns.
   * https://www.toptal.com/designers/subtlepatterns/black-thread/
   * Licensed under CC-BY-SA 3.0 US
   * https://creativecommons.org/licenses/by-sa/3.0/us/legalcode
   */
  background-image: url("/img/black-thread-light.png");
  background-size: auto;
}

body.printable,
#maincolumn,
.clickable4:not([href]),
button:hover,
input[type=submit]:hover,
.clickable1:hover:not(.disabled),
.bg-color-3 {
  background-color: #9aad90; /* chrome paisley light */
  /*
   * Background pattern from Toptal Subtle Patterns.
   * https://www.toptal.com/designers/subtlepatterns/black-thread/
   * Licensed under CC-BY-SA 3.0 US
   * https://creativecommons.org/licenses/by-sa/3.0/us/legalcode
   */

  background-image: url("/img/black-thread-light.png");
  background-size: auto;
}
#topNav,
/* body, */
.bg-color-4 {
  background-color: #444;
}
.a1,
a.a1:hover,
.bgColorTransparent {
  background-color: transparent;
}
.text1,
.bg-color-white {
  background-color: white;
}
.bg-color-5 {
  background-color: #77dd76;
}
.bg-color-6 {
  background-color: #05535b;  /* bluish */
}

body,
/* #leftcolumn, */
.container1,
.bg-color-7 {
  background-color: #e6dec7;  /* chrome paisley tan */
  background-color: #f2eee3;  /* chrome paisley tan half white */
}
.select1:hover,
.hover-1:hover,
.bg-color-8 {
  background-color: #d2d2b9;  /* chrome paisley tan leaf mix */
  background-color: #c7cebb;  /* chrome paisley tan half white leaf mix */
}

.mainheader,
.text3,
.color-2 {
  color: #504a43;  /* chrome paisley shadow */
}
.clickable4[href]:hover,
.color-3 {
  color: #9aad90; /* chrome paisley light */
}
.color-4 {
  color: #9aad90; /* chrome paisley light */
  color: #504a43;  /* chrome paisley shadow */
  color: #64765b;  /* chrome paisley leaf */
}
.clickable5,
.clickable4,
.color-4 {
  color: #9aad90; /* chrome paisley light */
  color: #504a43;  /* chrome paisley shadow */
}
.hoverlink-1,
.clickable5:hover,
.color-7 {
  color: #e6dec7;  /* chrome paisley tan */
  color: #f2eee3;  /* chrome paisley tan half white */
}
.hover-children:hover > .hover-child-2,
.clickable2:hover:not(.disabled),
.orange2 {
  color: #64765b;
}
.clickable2,
.input-text-1,
.text1,
.color-black {
  color: black;
}
.clickable4:not([href]),
button,
input[type=submit],
.clickable1,
.clickable3,
a,
.text2,
.text4,
.color-white {
  color: white;
}

svg {
  width: 100%;
  height: 100%;
}
label,
button,
input[type=submit],
a[href],
.clickable1:not(.disabled),
.clickable2:not(.disabled),
.cursor-pointer {
  cursor: pointer;
}

/* basic layout */
#maincolumn {
	position: fixed;
  height: 100%;
  overflow-y: auto;
  width: 82%;
  margin: 0 0 0 18%;
  text-align: left;
  top: 0;
}
@media print {
  .no-print, .no-print *
  {
    display: none !important;
  }
}
.printable .hide-on-printable {
  display: none;
}
.printable #maincolumn {
  position: relative;
  width: auto;
  height: 0;
  overflow-y: visible;
  margin: 0;
}
#leftcolumn {
  position: fixed;
  left: 0;
  top: 0;
  padding-top: 48px;
  padding-right: 1%;
  width: 18.5%;
  height: 100%;
  overflow-y: auto;
}
@media only screen and (min-width: 1400px) {
  #maincolumn {
    width: 64%;
  }
  #leftcolumn {
  }
}
.clickable4[href]:hover {
  transform: scale(1.05);
}
#topNav {
  width: 100%;
}
.mainheader {
  width: 100%;
  padding: 20px;
  font-size: 30px;
  font-weight: 500;
  text-align: center;
}
.clickable4,
.mainheader,
.text-transform-uppercase {
  text-transform: uppercase;
}
.workspace {
  padding: 0 32px 0 32px;
  width: 100%;
}
.container1 {
  padding: 10px;
  margin: 0px 0px 10px 0px;
  width: 100%;
}
.clickable4,
.clickable3,
.w100 { width: 100%; }
.w75 { width: 75%; }
.w67 { width: 67%; }
.w50 { width: 50%; }
.w33 { width: 33%; }
.w25 { width: 25%; }
.w20 { width: 20%; }
.w15 { width: 15%; }

.grabbable,
.grippy,
.grabby,
.cursorMoveGrab {
  cursor: move;
  cursor: grab;
  cursor: -moz-grab;
  cursor: -webkit-grab;
}

/* conditional hiding */
.drag-drop-1.gu-mirror .hidden3,
.hidden2,
.hidden1,
.hidden {
  visibility: hidden;
  transition: visibility 0s linear 0s !important;
}
.incrementsCounter .hidden1,
ol .hidden2:checked,
ol li:hover .hidden2 {
  visibility: visible;
}
.display-none-1 {
  display: none;
}
[data-isNew="new"] .display-none-1 {
  display: inline-block;
}

/* rank counting (FUNCTIONAL) */
/* increment the rank with each candidate by default */
.incrementsCounter > * {
  counter-increment: rank;
}
/* do not increment the rank for gu-transit items that fall after a tied item, nor the ranks for items within a tie that fall after a gu-transit item, since they might not be coming from a tie */
.incrementsCounter > [data-tie] + .gu-transit,
.incrementsCounter > .gu-transit + [data-tie="middle"],
.incrementsCounter > .gu-transit + [data-tie="end"],
.incrementsCounter > [data-tie] + [data-tie] {
  counter-increment: none;
}
.incrementsCounter > [data-tie] + [data-tie="start"]:not(.gu-transit),
/* increment the rank for gu-transit items that fall right after the end of a tie */
.incrementsCounter > [data-tie="end"] + .gu-transit {
  counter-increment: rank;
}
/* actually show the count */
.orderdisplay::before {
  position: absolute;
  top: 0;
  bottom: 0;
  left: 0;
  right: 0;
}
.incrementsCounter .orderdisplay::before {
  content: counter(rank);
}

/* other stuff */
a[href]:active,
button:active,
input[type=submit]:active,
.clickable1:active,
.clickable2:active,
.clickable1.disabled,
.clickable2.disabled,
.input-text-1.disabled,
.opacity5 {
  opacity: .5;
}
.label0,
/* label, */
input,
.input-text-1,
.text3,
a,
button,
input[type=submit],
textarea,
.clickable1,
/* .clickable1 select, */
.clickable2,
.clickable3,
.clickable {
  text-decoration: none;
  font-size: 20px;
  padding: 10px;
  border-radius: .15em;
  transition: all .25s;
}
.label0,
/* label, */
.input-text-1,
.text3,
a,
button,
input[type=submit],
.clickable1,
/* .clickable1 select, */
.clickable2,
.clickable3,
.clickable {
  -webkit-user-select: none;  /* Chrome all / Safari all */
  -moz-user-select: none;     /* Firefox all */
  -ms-user-select: none;      /* IE 10+ */
  user-select: none;          /* Likely future */
}
/* revamp */
.text1square {
  height: 41px;
  width: 41px;
  line-height: 41px;
  vertical-align: top;
}
.text2,
.font15 {
  font-size: 15px;
}
.text4,
.font16 {
  font-size: 16px;
}
.grabbable,
.text1square,
.text1,
.font20,
.font-size-1 {
  font-size: 20px;
}
.font-size-3 {
  font-size: 23px;
}
.font-size-4 {
  font-size: 18px;
}
.text4 {
  border-radius: 10px;
}
.text1,
.padding10 {
  padding: 10px;
}
.padding-1 {
  padding: 5px !important;
}
.padding-2 {
  padding: 0 0 0 20px !important;
}
.text4,
.padding-sides-small {
  padding: 0px 5px 0px 5px;
}
.padding-top-med {
  padding: 15px 0px 0px 0px;
}
.text2,
.paddingTop4 {
  padding: 4px 0px 0px 0px;
}
.text2,
.text1,
.textLeft {
  text-align: left;
}
.textRight {
  text-align: right;
}
.clickable4,
.text1square,
.textCenter {
  text-align: center;
}
.a1,
.underline {
  text-decoration: underline !important;
}
.font-weight-bold {
  font-weight: 800 !important;
}
.margin-bottom-2,
.margin-bottom-1 {
  margin: 0px 0px 4px 0px !important;
}
.margin-bottom-1:last-child {
  margin: 0;
}
.label0,
/* label, */
input,
.input-text-1,
.text3,
button,
input[type=submit],
.clickable1,
.clickable2,
.clickable3,
.margin-sides-1 {
  margin: 0px 2px 0px 2px;
}
.margin-right-1 {
  margin: 0px 6px 0px 0px;
}
/* noe removeable? */
.row-spacing1 {
  border-spacing: 0px 8px;
}
.table {
  display: table;
  table-layout: fixed;
}
.table > * {
  display: table-row;
}
.table > * > * {
  display: table-cell;
}
.select1,
.hover-1,
.transition-p25s {
  transition: all .15s;
}
.hoverlink-1,
.clickable5:hover,
.text-decoration-underline {
  text-decoration: underline;
}
.nowrap {
  white-space: nowrap !important;
}
.overflow-visible {
  overflow: visible !important;
}
.drag-drop-1.gu-mirror,
.border-none {
  border: none !important;
}
.border-1 {
  border-width: 1px;
  border-style: solid;
}
.input-text-1,
.border-bottom-2,
.border-bottom-1 {
  border-bottom-width: 1px;
  border-bottom-style: solid;
}
.input-text-1,
.font-weight-200 {
  font-weight: 200;
}
.hover-children:hover > .hover-child-1,
.input-text-1:hover,
.input-text-1:focus {
  outline: none;
}

.input-text-1::-webkit-input-placeholder { /* Chrome */
  color: #444;
  font-style: italic;
}
.input-text-1:-ms-input-placeholder { /* IE 10+ */
  color: #444;
  font-style: italic;
}
.input-text-1::-moz-placeholder { /* Firefox 19+ */
  color: #444;
  font-style: italic;
}
.input-text-1:-moz-placeholder { /* Firefox 4 - 18 */
  color: #444;
  font-style: italic;
}
.select1 {
   background: transparent;
	 font-size: inherit;
	 color: inherit;
	 cursor: pointer;
	 border: none;
	 border-bottom: solid 1px;
}
.select1:focus{
    outline: none;
}

/* custom checkbox adapted from https://www.w3schools.com/howto/howto_css_custom_checkbox.asp */
.checkbox0 {
	display: none;
  /* opacity: 0; */
}
/* Create a custom checkbox */
.checkboxUI0 {
  background-color: #eee;
  width: 16px;
  height: 16px;
  line-height: 16px;
  font-size: 16px;
  border-width: 1px;
  border-style: solid;
}
/* On mouse-over, add a grey background color */
input[type=checkbox]:focus + .checkboxUI0,
.checkboxUI0:hover {
  background-color: #ccc;
}
/* Create the checkmark/indicator (hidden when not checked) */
.checkboxUI0:after {
  content: "";
  position: absolute;
  display: none;
  left: 35%;
  top: 10%;
  width: 25%;
  height: 50%;
  border: solid white;
  border-width: 0 2px 2px 0;
  -webkit-transform: rotate(45deg);
  -ms-transform: rotate(45deg);
  transform: rotate(45deg);
}
/* Show the checkmark when checked */
[type=checkbox]:checked ~ .checkboxUI0:after {
  display: block;
}

/* for Alchemy graph stuff */
.node text {
    fill: black;
    font-weight: 200;
    text-anchor: middle;
    text-shadow: none;
}

.plot_area {
    width: 600px;
    height: 600px;
}
.centered,.centeredRegistrationButton {
    margin: auto;
    width: 50%;
    display: block;
}

.block {
    display: block;
}

#statusbar {
    width: 49%;
}

.darkhoverbackground:hover {
    background-color: #504a43;
}
.welcome-details {
    text-align: center;
}
.welcome-details a {
    margin-top: 1em;
    margin-bottom: 1em;
}
@media print {
	body, div {
		height: auto;
		overflow: visible !important;
		display: block;
	}
}


text: An API for multiblock structures support for the Bukkit API.


text: Termini e condizioni d\'uso


text:
public class Reports {
	String report;
	String type;
	String frequency;

	public String getReport() {
		return report;
	}
	public String getType() {
		return type;
	}
	public String getFrequency() {
		return frequency;
	}

}