text:
namespace Microsoft.Azure.Management.Network
{
    using Microsoft.Rest;
    using Microsoft.Rest.Azure;
    using Models;
    using System.Threading;
    using System.Threading.Tasks;

    /// <summary>
    /// Extension methods for ScopeConnectionsOperations.
    /// </summary>
    public static partial class ScopeConnectionsOperationsExtensions
    {
            /// <summary>
            /// Creates or updates scope connection from Network Manager
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='parameters'>
            /// Scope connection to be created/updated.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            public static ScopeConnection CreateOrUpdate(this IScopeConnectionsOperations operations, ScopeConnection parameters, string resourceGroupName, string networkManagerName, string scopeConnectionName)
            {
                return operations.CreateOrUpdateAsync(parameters, resourceGroupName, networkManagerName, scopeConnectionName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Creates or updates scope connection from Network Manager
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='parameters'>
            /// Scope connection to be created/updated.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<ScopeConnection> CreateOrUpdateAsync(this IScopeConnectionsOperations operations, ScopeConnection parameters, string resourceGroupName, string networkManagerName, string scopeConnectionName, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(parameters, resourceGroupName, networkManagerName, scopeConnectionName, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Get specified scope connection created by this Network Manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            public static ScopeConnection Get(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, string scopeConnectionName)
            {
                return operations.GetAsync(resourceGroupName, networkManagerName, scopeConnectionName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Get specified scope connection created by this Network Manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<ScopeConnection> GetAsync(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, string scopeConnectionName, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.GetWithHttpMessagesAsync(resourceGroupName, networkManagerName, scopeConnectionName, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// Delete the pending scope connection created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            public static void Delete(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, string scopeConnectionName)
            {
                operations.DeleteAsync(resourceGroupName, networkManagerName, scopeConnectionName).GetAwaiter().GetResult();
            }

            /// <summary>
            /// Delete the pending scope connection created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='scopeConnectionName'>
            /// Name for the cross-tenant connection.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task DeleteAsync(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, string scopeConnectionName, CancellationToken cancellationToken = default(CancellationToken))
            {
                (await operations.DeleteWithHttpMessagesAsync(resourceGroupName, networkManagerName, scopeConnectionName, null, cancellationToken).ConfigureAwait(false)).Dispose();
            }

            /// <summary>
            /// List all scope connections created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='top'>
            /// An optional query parameter which specifies the maximum number of records
            /// to be returned by the server.
            /// </param>
            /// <param name='skipToken'>
            /// SkipToken is only used if a previous operation returned a partial result.
            /// If a previous response contains a nextLink element, the value of the
            /// nextLink element will include a skipToken parameter that specifies a
            /// starting point to use for subsequent calls.
            /// </param>
            public static IPage<ScopeConnection> List(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, int? top = default(int?), string skipToken = default(string))
            {
                return operations.ListAsync(resourceGroupName, networkManagerName, top, skipToken).GetAwaiter().GetResult();
            }

            /// <summary>
            /// List all scope connections created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='resourceGroupName'>
            /// The name of the resource group.
            /// </param>
            /// <param name='networkManagerName'>
            /// The name of the network manager.
            /// </param>
            /// <param name='top'>
            /// An optional query parameter which specifies the maximum number of records
            /// to be returned by the server.
            /// </param>
            /// <param name='skipToken'>
            /// SkipToken is only used if a previous operation returned a partial result.
            /// If a previous response contains a nextLink element, the value of the
            /// nextLink element will include a skipToken parameter that specifies a
            /// starting point to use for subsequent calls.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<ScopeConnection>> ListAsync(this IScopeConnectionsOperations operations, string resourceGroupName, string networkManagerName, int? top = default(int?), string skipToken = default(string), CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListWithHttpMessagesAsync(resourceGroupName, networkManagerName, top, skipToken, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

            /// <summary>
            /// List all scope connections created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            public static IPage<ScopeConnection> ListNext(this IScopeConnectionsOperations operations, string nextPageLink)
            {
                return operations.ListNextAsync(nextPageLink).GetAwaiter().GetResult();
            }

            /// <summary>
            /// List all scope connections created by this network manager.
            /// </summary>
            /// <param name='operations'>
            /// The operations group for this extension method.
            /// </param>
            /// <param name='nextPageLink'>
            /// The NextLink from the previous successful call to List operation.
            /// </param>
            /// <param name='cancellationToken'>
            /// The cancellation token.
            /// </param>
            public static async Task<IPage<ScopeConnection>> ListNextAsync(this IScopeConnectionsOperations operations, string nextPageLink, CancellationToken cancellationToken = default(CancellationToken))
            {
                using (var _result = await operations.ListNextWithHttpMessagesAsync(nextPageLink, null, cancellationToken).ConfigureAwait(false))
                {
                    return _result.Body;
                }
            }

    }
}


text:
#include "globs.h"
#include "mainwindow.h"

#include <QMessageBox>
#include <QList>
#include <QString>
#include <QFont>
#include <QClipboard>
#include <QApplication>
#include <QDebug>
#include <QScrollArea>

#include <QMenuBar>
#include <QAction>
#include <QMenu>

#include "furiganabox.h"
#include "dicttool.h"
#include "mecabtool.h"

MainWindow::MainWindow(QWidget * /*parent*/ )
{
    /* Start dictionary and MeCab */
    dict = new DictTool;
    mecab = new MeCabTool(dict);

    /* Start UI */
    initUI();
    setup();
    show();
}

MainWindow::~MainWindow()
{
    delete mecab;
    delete dict;
}

void MainWindow::initUI()
{
    QAction *quit = new QAction("&Quit", this);

    QMenu *file;
    file = menuBar()-> addMenu("&File");
    file->addAction(quit);

    connect(quit, SIGNAL(triggered()), qApp, SLOT(quit()));

    scrollArea = new QScrollArea;

    furibox = new FuriganaBox(scrollArea);
    furibox->setMouseTracking(true);
    furibox->setDictionary(dict);

    QFont font1 = furibox->font();
    font1.setPointSize(18);
    furibox->setFont(font1);
    font1.setPointSize(10);
    furibox->setRubyFont(font1);
    furibox->setMinimumSize(100, 100);
    furibox->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::MinimumExpanding );

    scrollArea->setBackgroundRole(QPalette::Base);
    scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
    scrollArea->setWidgetResizable(true);
    scrollArea->setWidget(furibox);

    setCentralWidget(scrollArea);

    resize(850, 250);
    setWindowTitle("QYomi");
}

bool MainWindow::setup()
{
    if( !dict->init() )
    {
        QMessageBox::critical(
                this,
                "Can't start",
                "There was a problem opening the dictionary. Reason:\n\n" + dict->errorString());
        return false;
    }

    connect(QApplication::clipboard(), SIGNAL(dataChanged()),
            this, SLOT(clipboardChanged()));

    return true;
}

void MainWindow::clipboardChanged()
{
    QString text = QApplication::clipboard()->text();
    if(text != clipboardText)
    {
        furibox->setWords( mecab->parse(text) );
        clipboardText = text;
    }
}

redpajama_set_name: RedPajamaGithub


text:
require 'travis/build/stages/base'

module Travis
  module Build
    class Stages
      class Conditional < Base
        def run
          return unless config[name] || deployment?
          sh.if(condition) do
            Custom.new(script, name).run
          end
        end

        private

          def condition
            "$TRAVIS_TEST_RESULT #{operator} 0"
          end

          def operator
            name == :after_success ? '=' : '!='
          end
      end
    end
  end
end


text:
package com.spotify.docker.client.exceptions;

public class ImageNotFoundException extends NotFoundException {

  private final String image;

  public ImageNotFoundException(final String image, final Throwable cause) {
    super("Image not found: " + image, cause);
    this.image = image;
  }

  public ImageNotFoundException(final String image, final String message) {
    super("Image not found: " + image + ": " + message);
    this.image = image;
  }

  public ImageNotFoundException(final String image) {
    super("Image not found: " + image);
    this.image = image;
  }

  public String getImage() {
    return image;
  }
}


text:
/*
 * Do not modify this file. This file is generated from the ds-2015-04-16.normal.json service model.
 */
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml.Serialization;

using Amazon.DirectoryService.Model;
using Amazon.Runtime;
using Amazon.Runtime.Internal;
using Amazon.Runtime.Internal.Transform;
using Amazon.Runtime.Internal.Util;
using ThirdParty.Json.LitJson;

namespace Amazon.DirectoryService.Model.Internal.MarshallTransformations
{
    /// <summary>
    /// DescribeSnapshots Request Marshaller
    /// </summary>
    public class DescribeSnapshotsRequestMarshaller : IMarshaller<IRequest, DescribeSnapshotsRequest> , IMarshaller<IRequest,AmazonWebServiceRequest>
    {
        /// <summary>
        /// Marshaller the request object to the HTTP request.
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public IRequest Marshall(AmazonWebServiceRequest input)
        {
            return this.Marshall((DescribeSnapshotsRequest)input);
        }

        /// <summary>
        /// Marshaller the request object to the HTTP request.
        /// </summary>
        /// <param name="publicRequest"></param>
        /// <returns></returns>
        public IRequest Marshall(DescribeSnapshotsRequest publicRequest)
        {
            IRequest request = new DefaultRequest(publicRequest, "Amazon.DirectoryService");
            string target = "DirectoryService_20150416.DescribeSnapshots";
            request.Headers["X-Amz-Target"] = target;
            request.Headers["Content-Type"] = "application/x-amz-json-1.1";
            request.HttpMethod = "POST";

            string uriResourcePath = "/";
            request.ResourcePath = uriResourcePath;
            using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
            {
                JsonWriter writer = new JsonWriter(stringWriter);
                writer.WriteObjectStart();
                var context = new JsonMarshallerContext(request, writer);
                if(publicRequest.IsSetDirectoryId())
                {
                    context.Writer.WritePropertyName("DirectoryId");
                    context.Writer.Write(publicRequest.DirectoryId);
                }

                if(publicRequest.IsSetLimit())
                {
                    context.Writer.WritePropertyName("Limit");
                    context.Writer.Write(publicRequest.Limit);
                }

                if(publicRequest.IsSetNextToken())
                {
                    context.Writer.WritePropertyName("NextToken");
                    context.Writer.Write(publicRequest.NextToken);
                }

                if(publicRequest.IsSetSnapshotIds())
                {
                    context.Writer.WritePropertyName("SnapshotIds");
                    context.Writer.WriteArrayStart();
                    foreach(var publicRequestSnapshotIdsListValue in publicRequest.SnapshotIds)
                    {
                            context.Writer.Write(publicRequestSnapshotIdsListValue);
                    }
                    context.Writer.WriteArrayEnd();
                }

                writer.WriteObjectEnd();
                string snippet = stringWriter.ToString();
                request.Content = System.Text.Encoding.UTF8.GetBytes(snippet);
            }

            return request;
        }

    }
}


text:
/**
 * User: Ivan Pirus
 * Group: B14
 * Date: January 2016
 */

function PressEnter(your_text, your_event) {
    if(your_text != "" && your_event.keyCode == 13) {
        var emty = "Результати пошуку";
        $('h2#language').text(emty);
        $.get('content/controllers/con_route_search.php', {key: your_text}, function (data) {
            $('div.main_content').html(data);
        });
    }
};

$(document).ready(function(){
   $('button#button_search').click(function(){
       var text = $('input#search').val();
       var emty = "Результати пошуку";
       $('h2#language').text(emty);
       $.get('content/controllers/con_route_search.php', {key: text}, function(data){
           $('div.main_content').html(data);
       });
   });
});


text:
'use strict';

import 'vs/css!./dropdown';
import Builder = require('vs/base/browser/builder');
import WinJS = require('vs/base/common/winjs.base');
import Touch = require('vs/base/browser/touch');
import Actions = require('vs/base/common/actions');
import ActionBar = require('vs/base/browser/ui/actionbar/actionbar');
import EventEmitter = require('vs/base/common/eventEmitter');
import Lifecycle = require('vs/base/common/lifecycle');
import ContextView = require('vs/base/browser/ui/contextview/contextview');
import Menu = require('vs/base/browser/ui/menu/menu');

var $ = Builder.$;

export interface ILabelRenderer {
	(container: HTMLElement): Lifecycle.IDisposable;
}

export interface IBaseDropdownOptions {
	tick?: boolean;
	label?: string;
	labelRenderer?: ILabelRenderer;
	action?: Actions.IAction;
}

export class BaseDropdown extends Actions.ActionRunner {

	/*protected*/ toDispose: Lifecycle.IDisposable[];

	/*protected*/ $el: Builder.Builder;
	private $boxContainer: Builder.Builder;
	private $action: Builder.Builder;
	private $label: Builder.Builder;
	private $contents: Builder.Builder;

	constructor (container: HTMLElement, options: IBaseDropdownOptions) {
		super();

		this.toDispose = [];

		this.$el = $('.dropdown').appendTo(container);

		this.$label = $('.dropdown-label');

		if (options.tick || options.action) {
			this.$label.addClass('tick');
		}

		var labelRenderer = options.labelRenderer;

		if (!labelRenderer && options.action) {
			this.$action = $('.dropdown-action').appendTo(this.$el);

			var item = new ActionBar.ActionItem(null, options.action, {
				icon: true,
				label: true
			});

			item.actionRunner = this;
			item.render(this.$action.getHTMLElement());

			labelRenderer = (container: HTMLElement): Lifecycle.IDisposable => {
				container.innerText = '';
				return item;
			};
		}

		if (!labelRenderer) {
			labelRenderer = (container: HTMLElement): Lifecycle.IDisposable => {
				$(container).text(options.label || '');
				return null;
			};
		}

		this.$label.on(['click', Touch.EventType.Tap], (e:Event) => {
			e.preventDefault();
			e.stopPropagation();

			this.toggleDropdown();
		}).appendTo(this.$el);

		var cleanupFn = labelRenderer(this.$label.getHTMLElement());

		if (cleanupFn) {
			this.toDispose.push(cleanupFn);
		}

		this.toDispose.push(new Touch.Gesture(this.$label.getHTMLElement()));
	}

	public set tooltip(tooltip: string) {
		this.$label.title(tooltip);
	}

	/*protected*/ toggleDropdown(): void {
		if (this.$el.hasClass('active')) {
			this.hide();
		} else {
			this.show();
		}
	}

	/*protected*/ show(): void {
		// noop
	}

	/*protected*/ public hide(): void {
		// noop
	}

	/*protected*/ public onEvent(e:Event, activeElement: HTMLElement): void {
		this.hide();
	}

	public dispose(): void {
		super.dispose();
		this.hide();

		this.toDispose = Lifecycle.disposeAll(this.toDispose);

		if (this.$boxContainer) {
			this.$boxContainer.destroy();
			this.$boxContainer = null;
		}

		if (this.$contents) {
			this.$contents.destroy();
			this.$contents = null;
		}

		if (this.$label) {
			this.$label.destroy();
			this.$label = null;
		}
	}
}

export interface IDropdownOptions extends IBaseDropdownOptions {
	contextViewProvider: ContextView.IContextViewProvider;
}

export class Dropdown extends BaseDropdown {

	/*protected*/ _contextViewProvider: ContextView.IContextViewProvider;

	constructor (container: HTMLElement, options: IDropdownOptions) {
		super(container, options);
		this.contextViewProvider = options.contextViewProvider;
	}

	/*protected*/ public set contextViewProvider(contextViewProvider: ContextView.IContextViewProvider) {
		this._contextViewProvider = contextViewProvider;
	}

	/*protected*/ public get contextViewProvider(): ContextView.IContextViewProvider {
		return this._contextViewProvider;
	}

	/*protected*/ show(): void {
		this.$el.addClass('active');

		this._contextViewProvider.showContextView({
			getAnchor: () => this.$el.getHTMLElement(),

			render: (container) => {
				return this.renderContents(container);
			},

			onDOMEvent: (e, activeElement) => {
				this.onEvent(e, activeElement);
			},

			onHide: () => {
				this.$el.removeClass('active');
			}
		});
	}

	/*protected*/ public hide(): void {
		if (this._contextViewProvider) {
			this._contextViewProvider.hideContextView();
		}
	}

	/*protected*/ public renderContents(container: HTMLElement): Lifecycle.IDisposable {
		return null;
	}
}

export interface IContextMenuDelegate {
	getAnchor(): any;
	getActions(): WinJS.Promise;
	getActionItem?(action: Actions.IAction): ActionBar.IActionItem;
	getActionsContext?():any;
	getMenuClassName?():string;
	onHide?(didCancel: boolean): void;
}

export interface IContextMenuProvider {
	showContextMenu(delegate: IContextMenuDelegate): void;
}

export interface IActionProvider {
	getActions(): Actions.IAction[];
}

export interface IDropdownMenuOptions extends IBaseDropdownOptions {
	contextMenuProvider: IContextMenuProvider;
	actions?: Actions.IAction[];
	actionProvider?: IActionProvider;
	menuClassName?: string;
}

export class DropdownMenu extends BaseDropdown {

	/*protected*/ _contextMenuProvider: IContextMenuProvider;
	private _menuOptions: Menu.IMenuOptions;
	/*protected*/ currentContainer: HTMLElement;
	/*protected*/ _actions: Actions.IAction[];
	/*protected*/ actionProvider: IActionProvider;
	private menuClassName: string;

	constructor (container:HTMLElement, options: IDropdownMenuOptions) {
		super(container, options);

		this._contextMenuProvider = options.contextMenuProvider;
		this.currentContainer = null;
		this.actions = options.actions || [];
		this.actionProvider = options.actionProvider;
		this.menuClassName = options.menuClassName || '';
	}

	/*protected*/ public set contextMenuProvider(contextMenuProvider: IContextMenuProvider) {
		this._contextMenuProvider = contextMenuProvider;
	}

	/*protected*/ public get contextMenuProvider(): IContextMenuProvider {
		return this._contextMenuProvider;
	}

	public set menuOptions(options: Menu.IMenuOptions) {
		this._menuOptions = options;
	}

	public get menuOptions(): Menu.IMenuOptions {
		return this._menuOptions;
	}

	/*protected*/ public get actions(): Actions.IAction[] {
		if (this.actionProvider) {
			return this.actionProvider.getActions();
		}

		return this._actions;
	}

	/*protected*/ public set actions(actions:Actions.IAction[]) {
		this._actions = actions;
	}

	/*protected*/ show(): void {
		this.$el.addClass('active');

		this._contextMenuProvider.showContextMenu({
			getAnchor: () => this.$el.getHTMLElement(),
			getActions: () => WinJS.Promise.as(this.actions),
			getActionsContext: () => this.menuOptions ? this.menuOptions.context : null,
			getActionItem: (action) => this.menuOptions && this.menuOptions.actionItemProvider ? this.menuOptions.actionItemProvider(action) : null,
			getMenuClassName: () => this.menuClassName,
			onHide: () => {
				this.$el.removeClass('active');
				this.currentContainer = null;
			}
		});
	}

	/*protected*/ public hide(): void {
		// noop
	}
}

export class DropdownGroup extends EventEmitter.EventEmitter {

	private el: HTMLElement;

	constructor(container: HTMLElement) {
		super();

		this.el = document.createElement('div');
		this.el.className = 'dropdown-group';

		container.appendChild(this.el);
	}

	public get element(): HTMLElement {
		return this.el;
	}
}


text:
const path = require('path'),
    webpack = require('webpack'),
    HtmlWebpackPlugin = require('html-webpack-plugin'),
    ExtractTextPlugin = require('extract-text-webpack-plugin'),
    CopyWebpackPlugin = require('copy-webpack-plugin');

module.exports = {
    entry: './src/index.js',
    output: {
        filename: 'assets/js/main.js',
        path: path.resolve(__dirname, 'dist')
    },
    devtool: 'source-map',
    module: {
        loaders: [
            {
                test: /\.(js|jsx)$/,
                loader: 'babel-loader',
                exclude: /node_modules/,
                query: {
                    presets: ['es2015', 'react']
                }
            },
            {
                test: /\.js$/,
                exclude: /node_modules/,
                loader: 'eslint-loader'
            },
            {
                test: /\.scss$/,
                exclude: /node_modules/,
                use: ExtractTextPlugin.extract({
                    fallback: 'style-loader',
                    use: ['css-loader', 'resolve-url-loader', 'sass-loader?sourceMap']
                })
            },
            {
                test: /\.(ico|jpg|jpeg|png|gif|svg)(\?.*)?$/,
                loader: 'file-loader',
                options: {
                    publicPath: '../../',
                    name: 'assets/images/[name].[ext]',
                    limit: 10000
                }
            }
        ]
    },
    plugins: [
        new HtmlWebpackPlugin({
            template: './src/index.html'
        }),
        new ExtractTextPlugin({
            filename: 'assets/styles/main.css'
        }),
        new webpack.HotModuleReplacementPlugin(),
        new webpack.NamedModulesPlugin(),
        new CopyWebpackPlugin([{from: './src/manifest.json'}]),
        new CopyWebpackPlugin([{
            context: './src/assets/images',
            from: '**/*',
            to: 'assets/images'
        }])
    ],
    devServer: {
        compress: true,
        contentBase: path.join(__dirname, 'dist'),
        historyApiFallback: true,
        hot: true
    }
};


text:
<?php
namespace AymardBundle\EventListener;

use AymardBundle\Model\MenuItemModel;
use Avanzu\AdminThemeBundle\Event\SidebarMenuEvent;
use Symfony\Component\HttpFoundation\Request;

class MenuItemListListener {

    // ...

    public function onSetupMenu(SidebarMenuEvent $event) {

        $request = $event->getRequest();

        foreach ($this->getMenu($request) as $item) {
            $event->addItem($item);
        }

    }

    protected function getMenu(Request $request) {
        // Build your menu here by constructing a MenuItemModel array
        $menuItems = [
            $page = new MenuItemModel('page', 'Pages', 'admin_page_index', array(), 'iconclasses fa fa-plane'),
            $image = new MenuItemModel('image', 'Photos', 'admin_page_index', array(/* options */), 'iconclasses fa fa-plane'),
            $trans = new MenuItemModel('trans', 'Traductions', 'jms_translation_index', array('locale' => "fr"), 'iconclasses fa fa-plane'),
        ];
        $page->addChild(new MenuItemModel('page_list', 'List', 'admin_page_index', array(), 'fa fa-rss-square'));
        //$page->addChild(new MenuItemModel('page_new', 'Create', 'admin_page_new', array(), 'fa fa-rss-square'));
        $image->addChild(new MenuItemModel('image_list', 'List', 'admin_image_index', array(), 'fa fa-rss-square'));
        $image->addChild(new MenuItemModel('image_new', 'Create', 'admin_image_new', array(), 'fa fa-rss-square'));

        return $this->activateByRoute($request->get('_route'), $menuItems);
    }

    protected function activateByRoute($route, $items) {
        foreach($items as $item) {
            if($item->hasChildren()) {
                $this->activateByRoute($route, $item->getChildren());
            }
            else {
                if($item->getRoute() == $route) {
                    $item->setIsActive(true);
                }
            }
        }

        return $items;
    }

}


text:
There are two versions of CTL* synthesizer.
One, called with `./star.py --direct`, parses CTL* formula
and encodes `sys |= CTL*` directly into SMT.
Another, called with `./star.py --aht`, first translates CTL* into AHT,
then encodes non-emptiness of `sys * AHT` into SMT.
Both should in theory have the same performance,
but in practice, the direct approach is faster,
due to my naive implementation of translation `CTL* -> AHT`.

Below we focus on the `--aht` version.

The synthesizer via AHTs works as follows:

1) Parse the specification that describes inputs, outputs, and CTL* formula F.
   For this, we use files in python format.

2) Convert F into a hesitant tree automaton using the procedure described in [^1],
   using LTL3BA to convert path formulas into NBWs.

3) For each system size k in increasing order:

   - encode "is there M_k: M_k * AHT != 0?" into SMT
     using Eq.5 where |M_k| = k.

   - call Z3 solver:
     if the solver returns "unsatisfiable", goto next iteration;
     otherwise print the model in the dot graph format.

# Example

Consider the specification from file `resettable_arbiter1.py`:

```
from helpers.spec_helper import *
from interfaces.spec import Spec

rs1, r1 = sig_prop('r1')
gs1, g1 = sig_prop('g1')
rs2, r2 = sig_prop('r2')
gs2, g2 = sig_prop('g2')

inputs = [rs1,rs2]
outputs = [gs1,gs2]

formula = ~g1 & ~g2 & \
          AG((r1 >> F(g1)) & (r2 >> F(g2))) & \
          AG(~(g1&g2)) & \
          AGEF(~g1&~g2&~r1&~r2)

spec = Spec(inputs, outputs, formula)
```

Some techicality:
`rs1` means an object of class `Signal`,
while `r1` means the proposition `rs1 = True`;
also: `>>` denotes implication, `~` means negation,
and backslash is used to merge multi-lines into one.

To run it, from the tool root folder call

`python3 ./star.py ./experiments-for-tacas/resettable_arbiter1.py --dot model.dot`

(Call `python3 ./star.py --help` to see all possible parameters.)

You should get logs like
```
15:09:02  Namespace(bound=128, dot=None, incr=False, log=None, size=0, spec='./experiments-for-tacas/resettable_arbiter1.py', tmp=False, verbose=0)
15:09:02  check_real
15:09:02  ctl2aht:
 inputs: {r1, r2}
 outputs: {g2, g1}
 formula: !(g1=1) * !(g2=1) * A(G(!(r1=1) + F(g1=1) * !(r2=1) + F(g2=1))) * A(G(!(g1=1 * g2=1))) * A(G(E(F(!(g1=1) * !(g2=1) * !(r1=1) * !(r2=1)))))
15:09:02  replace_top_AEs
15:09:02  ctl2aht:
 inputs: {r1, r2}
 outputs: {g2, g1}
 formula: E(F(A(G(g1=1 + g2=1 + r1=1 + r2=1))))

[cut away some logs]

15:10:35  The AHT automaton size (nodes/transitions) is: 13/24
15:10:35  search
15:10:35  searching a model of size 1..
15:10:36  solve
15:10:36  solving /home/ayrat/projects/party-elli/tmpvk05_g1q1.smt2
15:10:36  searching a model of size 2..
15:10:36  solve
15:10:36  solving /home/ayrat/projects/party-elli/tmpvk05_g1q1.smt2
15:10:36  searching a model of size 3..
15:10:36  solve
15:10:36  solving /home/ayrat/projects/party-elli/tmpvk05_g1q1.smt2
15:10:36  _parse_sys_model
15:10:36  FOUND model for sys
15:10:36  Moore model is written to model.dot
```

Most of the logs (that are cut) are taken by messages about translation of CTL* into AHT
-- this is also the most difficult part to implement.

After getting an AHT, at moment `15:10:35`, the tool starts SMT solving.
In this example, the smallest model is of size 3.
The model is written into `model.dot` which looks like
(it may differ in your case, since there are many different models satisfying this spec,
 but the size should be 3):

  ![](postponed_arbiter.png)

That is all.

The folder `experiments-for-tacas` contains other specifications to try out.
They are all realizable -- on unrealizable specs the tool does not terminate
(hangs in iterating over model sizes).

If you wonder about alternating hesitant automata -- see small note in [aht.md](aht.md).

## Notes

- Two encoders for CTL* are `synthesis/ctl/ctl_encoder_direct.py` and `synthesis/ctl/ctl_encoder_via_aht.py`.
  The translation `CTL* -> AHT` is in `ctl2aht_/ctl2aht.py`.
- The encoder for LTL is in `synthesis/cobuchi_smt_encoder.py` and `buchi_cobuchi_encoder.py`
- The input format for CTL* is python format, see examples in `benchmarks/ctl` and `experiments-for-cav`.

  [^1]: Kupferman, O., Vardi, M.Y., Wolper, P.: An automata-theoretic approach to branching-time model checking.


text:
SoundEngine::SoundEngine(int soundEffectsVolume, int musicVolume, QObject *parent) :
    QObject(parent)
{
    Phonon::AudioOutput *shootOutput = new Phonon::AudioOutput(Phonon::GameCategory, this);
    shootOutput->setVolume(soundEffectsVolume / 100.0);
    Phonon::AudioOutput *satOutput = new Phonon::AudioOutput(Phonon::GameCategory, this);
    satOutput->setVolume(soundEffectsVolume / 100.0);
    Phonon::AudioOutput *snovaOutput = new Phonon::AudioOutput(Phonon::GameCategory, this);
    snovaOutput->setVolume(soundEffectsVolume / 100.0);

    Phonon::AudioOutput *musicOutput = new Phonon::AudioOutput(Phonon::MusicCategory, this);
    musicOutput->setVolume(musicVolume / 100.0);

    shootMediaObject = new Phonon::MediaObject(this);
    shootMediaObject->setCurrentSource(Phonon::MediaSource(":/sounds/laser"));
    Phonon::createPath(shootMediaObject, shootOutput);

    satMediaObject = new Phonon::MediaObject(this);
    satMediaObject->setCurrentSource(Phonon::MediaSource(":/sounds/sat"));
    Phonon::createPath(satMediaObject, satOutput);

    snovaMediaObject = new Phonon::MediaObject(this);
    snovaMediaObject->setCurrentSource(Phonon::MediaSource(":/sounds/supernova"));
    Phonon::createPath(snovaMediaObject, snovaOutput);

    musicMediaObject = new Phonon::MediaObject(this);
    musicMediaObject->setCurrentSource(Phonon::MediaSource(":/sounds/bgmusic"));
    Phonon::createPath(musicMediaObject, musicOutput);
    connect(musicMediaObject, SIGNAL(aboutToFinish()), this, SLOT(musicFinished()));
    musicMediaObject->play();
}

void SoundEngine::playSound(Sounds toPlay)
{
    if(toPlay == SatelliteSound)
    {
        satMediaObject->seek(0);
        satMediaObject->play();
    }
    else if(toPlay == ShootSound)
    {
        shootMediaObject->seek(0);
        shootMediaObject->play();
    }
    else if(toPlay == SupernovaSound)
    {
        snovaMediaObject->seek(0);
        snovaMediaObject->play();
    }
}

void SoundEngine::musicFinished()
{
    musicMediaObject->enqueue(Phonon::MediaSource(":/sounds/bgmusic"));
}


text:
import time

class Expecter(object):
    def __init__(self, spawn, searcher, searchwindowsize=-1):
        self.spawn = spawn
        self.searcher = searcher
        if searchwindowsize == -1:
            searchwindowsize = spawn.searchwindowsize
        self.searchwindowsize = searchwindowsize

    def new_data(self, data):
        spawn = self.spawn
        searcher = self.searcher

        incoming = spawn.buffer + data
        freshlen = len(data)
        index = searcher.search(incoming, freshlen, self.searchwindowsize)
        if index >= 0:
            spawn.buffer = incoming[searcher.end:]
            spawn.before = incoming[: searcher.start]
            spawn.after = incoming[searcher.start: searcher.end]
            spawn.match = searcher.match
            spawn.match_index = index
            # Found a match
            return index

        spawn.buffer = incoming

    def eof(self, err=None):
        spawn = self.spawn
        from . import EOF

        spawn.before = spawn.buffer
        spawn.buffer = spawn.string_type()
        spawn.after = EOF
        index = self.searcher.eof_index
        if index >= 0:
            spawn.match = EOF
            spawn.match_index = index
            return index
        else:
            spawn.match = None
            spawn.match_index = None
            msg = str(spawn)
            if err is not None:
                msg = str(err) + '\n' + msg
            raise EOF(msg)

    def timeout(self, err=None):
        spawn = self.spawn
        from . import TIMEOUT

        spawn.before = spawn.buffer
        spawn.after = TIMEOUT
        index = self.searcher.timeout_index
        if index >= 0:
            spawn.match = TIMEOUT
            spawn.match_index = index
            return index
        else:
            spawn.match = None
            spawn.match_index = None
            msg = str(spawn)
            if err is not None:
                msg = str(err) + '\n' + msg
            raise TIMEOUT(msg)

    def errored(self):
        spawn = self.spawn
        spawn.before = spawn.buffer
        spawn.after = None
        spawn.match = None
        spawn.match_index = None

    def expect_loop(self, timeout=-1):
        """Blocking expect"""
        spawn = self.spawn
        from . import EOF, TIMEOUT

        if timeout is not None:
            end_time = time.time() + timeout

        try:
            incoming = spawn.buffer
            spawn.buffer = spawn.string_type()  # Treat buffer as new data
            while True:
                idx = self.new_data(incoming)
                # Keep reading until exception or return.
                if idx is not None:
                    return idx
                # No match at this point
                if (timeout is not None) and (timeout < 0):
                    return self.timeout()
                # Still have time left, so read more data
                incoming = spawn.read_nonblocking(spawn.maxread, timeout)
                time.sleep(0.0001)
                if timeout is not None:
                    timeout = end_time - time.time()
        except EOF as e:
            return self.eof(e)
        except TIMEOUT as e:
            return self.timeout(e)
        except:
            self.errored()
            raise


text:
#pragma once

#include "hazelcast/client/txn/TransactionProxy.h"
#include "hazelcast/client/proxy/SerializingProxy.h"

#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4251) // for dll export
#endif

namespace hazelcast {
namespace client {
namespace connection {
class Connection;
}

namespace proxy {
class HAZELCAST_API TransactionalObject : public proxy::SerializingProxy
{
public:
    TransactionalObject(const std::string& service_name,
                        const std::string& object_name,
                        txn::TransactionProxy& context);

    virtual ~TransactionalObject();

    const std::string& get_service_name();

    const std::string& get_name();

    boost::future<void> destroy();

protected:
    virtual void on_destroy();

    boost::uuids::uuid get_transaction_id() const;

    std::chrono::milliseconds get_timeout() const;

    const std::string service_name_;
    const std::string name_;
    txn::TransactionProxy& context_;
};
} // namespace proxy
} // namespace client
} // namespace hazelcast

#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif


text:
/*************************************************************************/
/*                                                                       */
/*                  Language Technologies Institute                      */
/*                     Carnegie Mellon University                        */
/*                        Copyright (c) 1999                             */
/*                        All Rights Reserved.                           */
/*                                                                       */
/*  Permission is hereby granted, free of charge, to use and distribute  */
/*  this software and its documentation without restriction, including   */
/*  without limitation the rights to use, copy, modify, merge, publish,  */
/*  distribute, sublicense, and/or sell copies of this work, and to      */
/*  permit persons to whom this work is furnished to do so, subject to   */
/*  the following conditions:                                            */
/*   1. The code must retain the above copyright notice, this list of    */
/*      conditions and the following disclaimer.                         */
/*   2. Any modifications must be clearly marked as such.                */
/*   3. Original authors' names are not deleted.                         */
/*   4. The authors' names are not used to endorse or promote products   */
/*      derived from this software without specific prior written        */
/*      permission.                                                      */
/*                                                                       */
/*  CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK         */
/*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      */
/*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   */
/*  SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE      */
/*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    */
/*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   */
/*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          */
/*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       */
/*  THIS SOFTWARE.                                                       */
/*                                                                       */
/*************************************************************************/
/*             Author:  Alan W Black (awb@cs.cmu.edu)                    */
/*               Date:  December 1999                                    */
/*************************************************************************/
/*                                                                       */
/*  Letter to sound rules                                                */
/*                                                                       */
/*************************************************************************/
#ifndef _CST_LTS_H__
#define _CST_LTS_H__

#include "cst_val.h"

typedef unsigned short cst_lts_addr;
typedef int cst_lts_phone;
typedef unsigned char  cst_lts_feat;
typedef unsigned char  cst_lts_letter;
typedef unsigned char  cst_lts_model;

/* end of rule value */
#define CST_LTS_EOR 255

typedef struct cst_lts_rules_struct {
    char *name;
    const cst_lts_addr *letter_index;  /* index into model first state */
    const cst_lts_model *models;
    const char * const * phone_table;
    int context_window_size;
    int context_extra_feats;
    const char * const * letter_table;
} cst_lts_rules;

/* Note this is designed to be 6 bytes */
typedef struct cst_lts_rule_struct {
    cst_lts_feat   feat;
    cst_lts_letter val;
    cst_lts_addr   qtrue;
    cst_lts_addr   qfalse;
} cst_lts_rule;

cst_lts_rules *new_lts_rules();

cst_val *lts_apply(const char *word,const char *feats,const cst_lts_rules *r);
cst_val *lts_apply_val(const cst_val *wlist,const char *feats,const cst_lts_rules *r);

#endif


text:
    <form name="scheduleForm" ng-submit="editSchedule()">

              Active

              <switch name="send_to_onfleet" color="success" ng-model="refill_schedule.active"></switch>

              Repeat Schedule

            <button class="btn btn-danger" ng-click="deleteSchedule()">
              Delete Schedule
            </button>
            <button class="btn btn-primary" type="submit">
              Edit Schedule
            </button>

    </form>


text:
layout: base
---

404

Oops. These are not the pixels you are looking for.


text:
'use strict';

/**
 * This is an example React Native app demonstrates ListViews, text input and
 * navigation between a few screens.
 * https://github.com/facebook/react-native
 */

import React, { Component } from 'react';
import { StackNavigator } from 'react-navigation';

import HomeScreenTabNavigator from './views/HomeScreenTabNavigator';
import ChatScreen from './views/chat/ChatScreen';

/**
 * Top-level navigator. Renders the application UI.
 */
const App = StackNavigator({
  Home: {
    screen: HomeScreenTabNavigator,
  },
  Chat: {
    screen: ChatScreen,
  },
});

export default App;


text:
class App {}
export const a = <App></App>;
// @filename: node_modules/@types/react/package.json
{
    "name": "@types/react",
    "version": "0.0.1",
    "main": "",
    "types": "index.d.ts",
}
// @filename: node_modules/@types/react/index.d.ts
interface IntrinsicClassAttributesAlias<T> {
    ref: T
}
declare namespace JSX {
    type IntrinsicClassAttributes<T> = IntrinsicClassAttributesAlias<T>
}
// @filename: node_modules/@types/react/jsx-runtime.d.ts
import './';
// @filename: node_modules/@types/react/jsx-dev-runtime.d.ts
import './';


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Eesti NSV Tead. Akad. Toim. , Biol. seer 16(4): 380 (1967)

#### Original name
Athelia bicolor f. fumosa Parmasto

### Remarks
null


text:
'use strict';

describe('Directive: back', function () {

  // load the directive's module
  beforeEach(module('myNewProjectApp'));

  var element,
    scope;

  beforeEach(inject(function ($rootScope) {
    scope = $rootScope.$new();
  }));

  it('should make hidden element visible', inject(function ($compile) {
    element = angular.element('<back></back>');
    element = $compile(element)(scope);
    expect(element.text()).toBe('this is the back directive');
  }));
});


text:
class PlaylistsUsers < ActiveRecord::Base
  belongs_to :playlist
  belongs_to :user

  validates :playlist, presence:true
  validates :user, presence:true
end


text:
import * as slurmApi from '@waldur/slurm/details/api';

import {
  getField,
  renderSummary,
  resource,
  associations,
} from './SlurmAllocationSummary.fixture';

jest.mock('@waldur/core/Link', () => {
  return {
    Link: ({ label, children }) => <a>{label || children}</a>,
  };
});
jest.mock('@waldur/slurm/details/api');

const slurmApiMock = slurmApi as jest.Mocked<typeof slurmApi>;

jest.mock('@waldur/configs/default', () => ({
  ENV: {
    plugins: { WALDUR_FREEIPA: { ENABLED: true, USERNAME_PREFIX: 'waldur_' } },
  },
}));

describe('SlurmAllocationSummary', () => {
  it('renders quota usage', async () => {
    const wrapper = await renderSummary({ resource });
    expect(getField(wrapper, 'CPU')).toBe('2.00h of 40.00h');
    expect(getField(wrapper, 'GPU')).toBe('0.00h of ∞');
    expect(getField(wrapper, 'RAM')).toBe('1 GB-h of 1 GB-h');
  });

  it('renders login details', async () => {
    const wrapper = await renderSummary({ resource });
    expect(getField(wrapper, 'Login with')).toBe('ssh admin@example.com');
  });

  it('renders placeholder if login details are absent', async () => {
    const wrapper = await renderSummary({
      resource: { ...resource, username: undefined },
    });
    expect(getField(wrapper, 'Login with')).toBe(
      'FreeIPA account needs to be set up.',
    );
  });

  it('renders submit details for SLURM', async () => {
    slurmApiMock.getSlurmAssociations.mockResolvedValue(associations);
    const wrapper = await renderSummary({ resource });
    expect(getField(wrapper, 'Submit with')).toBe('sbatch -A VALID_ID');
  });

  it("renders message for SLURM when association between user and allocation doesn't exist", async () => {
    slurmApiMock.getSlurmAssociations.mockResolvedValue([]);
    const wrapper = await renderSummary({ resource });
    expect(getField(wrapper, 'Submit with')).toBe(
      'Your account is not authorized to use this allocation',
    );
  });

  it('renders documentation link', async () => {
    slurmApiMock.getSlurmAssociations.mockResolvedValue(associations);
    const homepage = 'https://example.com/';
    const resource_data = { ...resource, homepage };
    const wrapper = await renderSummary({ resource: resource_data });
    const link = wrapper.find({ label: 'Submit with' }).find('a').first();
    expect(link.prop('href')).toBe(homepage);
  });
});


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.11"/>
<title>SideCar: Data Fields</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="DoxygenStyleSheet.css" rel="stylesheet" type="text/css" />

SideCar

Main Page

Related Pages

Modules

Namespaces

Data Structures

Files

Data Structures

Class Hierarchy

Data Fields

All

Functions

Variables

Typedefs

Enumerations

Enumerator

Related Functions

_

a

b

c

d

e

f

g

h

i

j

k

l

m

n

o

p

q

r

s

t

u

v

w

x

z

~

Here is a list of all documented struct and union fields with links to the struct/union documentation for each field:

- q -

QCheckBoxSetting()
: SideCar::GUI::QCheckBoxSetting

QColorSetting()
: SideCar::GUI::QColorSetting

QComboBoxSetting()
: SideCar::GUI::QComboBoxSetting

QDoubleSpinBoxSetting()
: SideCar::GUI::QDoubleSpinBoxSetting

QSpinBoxSetting()
: SideCar::GUI::QSpinBoxSetting

QTimeEditSetting()
: SideCar::GUI::QTimeEditSetting

QtMonitor()
: SideCar::GUI::QtMonitor

<address class="footer">
Generated by

 1.8.11
</address>


text:
package piinqcite.bar.filter;

import java.io.IOException;

import javax.inject.Inject;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import piinqcite.bar.model.User;
import piinqcite.bar.services.UserContext;

//@WebFilter("/bar")
//public class ProtectedResourcesFilter implements Filter{
	public class ProtectedResourcesFilter{
//
//	@Inject
//	UserContext userContext;
//
//	@Override
//	public void init(FilterConfig fCongig) throws ServletException{
//	}
//
//	@Override
//	public void destroy() {
//	}
//
//	@Override
//	public void doFilter(ServletRequest request, ServletResponse response,
//			FilterChain chain) throws IOException, ServletException {
//		if(!isHttpCall(request, response)){
//			return;
//		}
//		HttpServletRequest httpServletReqest = (HttpServletRequest) request;
//		HttpServletResponse httServletResponse = (HttpServletResponse) response;
//		User currentUser = userContext.getCurrentUser();
//		if(currentUser == null){
//			String loginUrl = httpServletReqest.getContextPath() + "/login.html";
//			httServletResponse.sendRedirect(loginUrl);
//		}
//		chain.doFilter(request, response);
//	}
//
//	private boolean isHttpCall(ServletRequest request, ServletResponse response){
//		return (request instanceof HttpServletRequest) && (response instanceof HttpServletResponse);
//	}
}


text:
package models

import java.net.URI

case class Release(connectionId: String, correlationId: String, replyTo: Option[URI], requesterNsa: String, provider: Provider)
    extends NsiRequest(correlationId, replyTo, requesterNsa, provider) {

  override def soapActionSuffix = "release"

  override def nsiV2Body =
    <type:release>
      <connectionId>{ connectionId }</connectionId>
    </type:release>
}


text:
using System;
using System.Collections.Generic;
using Mono.Options;
using Vinchuca;

namespace REPL.Commands
{
    class ExecuteCommand : Command
    {
        private readonly CommandLineReader _repl;
        public bool ShowHelp { get; set; }

        public ExecuteCommand(Agent agent, CommandLineReader repl)
            : base("execute", "Execute a shell command in all the peers")
        {
            _repl = repl;
            Options = new OptionSet() {
                "usage: execute command",
                "",
                "Execute a shell command in all the peers. It doesn't return the output.",
                "eg: execute copy ~my.tmp c:\\Program Files (x86)\\Notepad++\\unistall.exe",
                { "help|h|?","Show this message and exit.", v => ShowHelp = v != null },
            };
            _repl.AddAutocompletionWords("execute");
        }

        public override int Invoke(IEnumerable<string> args)
        {
            try
            {
                var extra = Options.Parse(args);
                if (ShowHelp)
                {
                    Options.WriteOptionDescriptions(CommandSet.Out);
                    return 0;
                }
                if (extra.Count == 0)
                {
                    Console.WriteLine("commands: Missing required argument `command`.");
                    Console.WriteLine("commands: Use `help execute` for details.");
                    return 1;
                }
                ///
                return 0;
            }
            catch (Exception e)
            {
                //_repl.Console.WriteLine("commands: {0}", CommandDemo.Verbosity >= 1 ? e.ToString() : e.Message);
                return 1;
            }
        }
    }
}


text:
using UnityEngine;
using System.Collections;

namespace Tetris
{
	public interface IGameView {
		void MakePiece(Vector3 pos, int ID);
		void DestroyPiece(int ID);

		void MovePiece(int ID, Vector3 pos);
	}
}


text:
package org.zoomeye.api.facets;

import java.util.List;

/**
 * Created by Donglua on 16/4/27.
 */
public class AppCount extends FacetCount {

  private String app;
  private List<VersionCount> versions;

  @Override public String getName() {
    return app;
  }
}


text:
layout: mappa
title: Rassegna stampa
permalink: /rassegnastampa/
---

<iframe src='//cdn.knightlab.com/libs/timeline3/latest/embed/index.html?source=1ceZXZEYkvExfbxPxipYipb-5FDrqA-Yh9QYlFaMsV4o&font=Default&lang=it&hash_bookmark=true&initial_zoom=2&height=650' width='100%' height='650' frameborder='0'></iframe>


text:
package org.nkjmlab.webui.jsonrpc;

import java.io.OutputStream;
import java.net.URL;
import java.util.Arrays;

import javax.servlet.http.HttpServletResponse;

import org.nkjmlab.util.slack.SlackMessage;
import org.nkjmlab.util.slack.SlackMessageBuilder;
import org.nkjmlab.util.slack.SlackMessengerService;
import org.nkjmlab.webui.ApplicationContext;

import jp.go.nict.langrid.commons.rpc.RpcFaultUtil;
import jp.go.nict.langrid.commons.rpc.json.JsonRpcRequest;
import jp.go.nict.langrid.commons.rpc.json.JsonRpcResponse;
import jp.go.nict.langrid.commons.ws.ServiceContext;
import jp.go.nict.langrid.servicecontainer.handler.ServiceLoader;

public class JsonRpcDynamicHandlerWithErrorNotifierToSlack
		extends JsonRpcDynamicHandlerWithErrorHandler {

	protected URL postUrl;
	protected String username;
	protected String channel = "log-srv";
	protected String icon = ":ghost:";

	public JsonRpcDynamicHandlerWithErrorNotifierToSlack() {
	}

	@Override
	protected void handleError(ServiceContext sc, ServiceLoader sl, String serviceName,
			JsonRpcRequest req, HttpServletResponse response, OutputStream os, JsonRpcResponse res,
			Throwable t) {
		try {
			if (postUrl == null) {
				postUrl = ApplicationContext.getSlackWebhookUrl();
			}

			if (postUrl == null) {
				throw new RuntimeException("post url should be set.");
			}

			SlackMessengerService.asyncPostMessage(postUrl,
					new SlackMessage(channel, (username != null ? username : serviceName),
							createJsonRpcFaultMessage(sc, req, t), "", icon));
		} catch (Exception e) {
			log.error(e, e);
		}
	}

	protected static String createJsonRpcFaultMessage(ServiceContext sc, JsonRpcRequest req,
			Throwable t) {
		return SlackMessageBuilder.AT_CHANNEL + " " + SlackMessageBuilder.ICON_ERROR + " "
				+ sc.getRequestUrl() + " :"
				+ (req.getMethod() != null ? req.getMethod() : "")
				+ (req.getParams() != null ? Arrays.asList(req.getParams()) : "")
				+ " " + SlackMessageBuilder.wrapPre(
						RpcFaultUtil.throwableToRpcFault("Server.userException", t).toString());
	}

}


text:
import { Angulartics2 } from '../../angulartics2-core';
import * as i0 from "@angular/core";
export declare class Angulartics2Pyze {
    private angulartics2;
    constructor(angulartics2: Angulartics2);
    startTracking(): void;
    pageTrack(path: string): void;
    eventTrack(action: string, properties: any): void;
    setUserId(userId: string): void;
    postTraits(properties: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Angulartics2Pyze, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Angulartics2Pyze>;
}


text:
name "os-block-storage-volume"
description "OpenStack Block Storage volume service"
run_list(
  "role[os-base]",
  "recipe[openstack-block-storage::volume]"
  )


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright 2005-2014 The Kuali Foundation

    Licensed under the Educational Community License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.opensource.org/licenses/ecl2.php

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.0.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

  <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <tx:method name="*"/>
    </tx:attributes>
  </tx:advice>

  <aop:config>
    <aop:pointcut id="controllerTransaction"
                  expression="execution(* org.kuali.rice.krad.web.controller.UifControllerBase+.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="controllerTransaction"/>
  </aop:config>

  <bean id="userTransaction" class="org.kuali.rice.core.framework.persistence.jta.UserTransactionFactoryBean"
        lazy-init="true"/>

  <bean id="jtaTransactionManager" class="org.kuali.rice.core.framework.persistence.jta.TransactionManagerFactoryBean"
        lazy-init="true"/>

  <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" lazy-init="true">
    <property name="userTransaction">
      <ref local="userTransaction"/>
    </property>
    <property name="transactionManager">
      <ref local="jtaTransactionManager"/>
    </property>
  </bean>

  <bean class="org.kuali.rice.krad.uif.freemarker.FreeMarkerInlineRenderBootstrap" />

  <bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
    <property name="preferFileSystemAccess" value="false" />
    <property name="templateLoaderPath" value="/"/>
    <property name="freemarkerSettings">
      <props>
        <prop key="number_format">computer</prop>
        <prop key="template_update_delay">2147483647</prop>
      </props>
    </property>
  </bean>

  <bean id="viewResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
    <property name="cache" value="true"/>
    <property name="prefix" value=""/>
    <property name="suffix" value=".ftl"/>
  </bean>

  <bean id="handlerMapping" class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
    <property name="interceptors">
      <list>
        <ref bean="uifControllerHandlerInterceptor"/>
        <ref bean="moduleLockingHandlerInterceptor"/>
      </list>
    </property>
  </bean>

  <bean id="uifControllerHandlerInterceptor"
        class="org.kuali.rice.krad.web.controller.UifControllerHandlerInterceptor"/>

  <bean id="moduleLockingHandlerInterceptor" class="org.kuali.rice.krad.web.controller.ModuleLockingHandlerInterceptor">
    <property name="moduleLockedMapping" value="module-locked"/>
    <property name="kualiModuleService" ref="kualiModuleService"/>
  </bean>

  <bean id="kualiModuleService" class="org.kuali.rice.core.framework.resourceloader.GlobalResourceLoaderServiceFactoryBean">
    <property name="serviceName" value="kualiModuleService"/>
  </bean>

  <bean id="exceptionResolver" class="org.kuali.rice.krad.web.controller.UifHandlerExceptionResolver"/>

  <bean class="org.kuali.rice.krad.web.controller.UifRequestMappingHandlerAdapter">
    <property name="webBindingInitializer">
      <ref bean="kradConfigurableWebBindingInitializer"/>
    </property>
    <property name="messageConverters">
      <list>
        <bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.ResourceHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.xml.SourceHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter"/>
      </list>
    </property>
  </bean>

  <bean id="kradConfigurableWebBindingInitializer"
        class="org.kuali.rice.krad.web.bind.UifConfigurableWebBindingInitializer"/>

  <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="500000"/>
  </bean>

  <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="basenames">
      <list>
        <value>org/kuali/rice/krad/ApplicationResources</value>
        <value>org/kuali/rice/krad/KRADApplicationResources</value>
      </list>
    </property>
  </bean>

</beans>


text:
<!COMIENZA FOOTER!-->

							OSEP
							 © <?php  echo(date("Y")) ?>

		</script>

		<link rel="stylesheet" href="<?php echo base_url() ?>assets/css/ace.onpage-help.css" />


text:
class Musique < Cask
  url 'http://flavio.tordini.org/files/musique/musique.dmg'
  appcast 'http://flavio.tordini.org/musique-ws/appcast.xml'
  homepage 'http://flavio.tordini.org/musique'
  version 'latest'
  sha256 :no_check
  link 'Musique.app'
end


text:
package org.clinical3PO.hadoop.mappers;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.clinical3PO.environment.EnvironmentType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PatientUniqueCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> { //Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT>

	private String envType = null;
	private int validLenOfObservationList = 0;
	private static final Logger logger = LoggerFactory.getLogger(PatientUniqueCountMapper.class);

	PatientUniqueCountMapper() {
		String temp = "observation_id;person_id;observation_concept_id;observation_date;"
				+ "observation_time;value_as_number;value_as_string;value_as_concept_id;unit_concept_id;"
				+ "range_low;range_high;observation_type_concept_id;associated_provider_id;visit_occurrence_id;"
				+ "relevant_condition_concept_id;observation_source_value;units_source_value";
		validLenOfObservationList = temp.split(";").length;
	}

	@Override
	public void setup(Context context) throws IOException, InterruptedException {
		envType = context.getConfiguration().get("envType");
	}

	@Override
	public void map(LongWritable key, Text value, Context context)
			throws IOException, InterruptedException {

		if(value != null && !value.equals(null)) {
			String line = value.toString();

			if(envType != null && EnvironmentType.DEVELOPMENT == EnvironmentType.valueOf(envType)) {
				logger.info ("Value of line : " + line);
			}
			String[] pIdArray = line.split(";");

			// checking if the record is complete or not.
			if(pIdArray.length == validLenOfObservationList) {

				if (!pIdArray[1].matches("person_id")) {  // skipping 1st line
					context.write(new Text(pIdArray[1]),  new IntWritable(0));
				}
			} else {
				logger.error("Parameters provided are incorect. ");
			}
		} else {
			logger.error("File provides ");
		}
	}
}


text:
package gameView;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

import javax.imageio.ImageIO;
import javax.swing.BoxLayout;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.ScrollPaneConstants;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

import jgame.JGObject;

import menus.Bar;

import engine.objects.Coin;
import engine.objects.Enemy;
import engine.objects.Level;
import engine.objects.LevelEndObject;
import engine.objects.MovingObject;
import engine.objects.Platform;
import engine.objects.Player;
import engine.objects.GameEngine;
import gameData.json.DataFile;
import gameData.json.Model;

@SuppressWarnings("serial")
public class MainPanel extends JPanel {
	private GameEngine myEngine;
	private Model myModel;
	public GamePanel myPanel;
	private DataFile data;
	public JTabbedPane pane;
	private int myTempInt;
	private Bar myBar;
	String file = "";
	private boolean isFirstRun;
	private Map<Integer,String> ImageMap=new HashMap<Integer,String>();
	private static final String IMAGE_FILE="src/gameViewResources/ImageFiles";

	public MainPanel(GameEngine engine, Model m, String s, Bar b) throws UnsupportedEncodingException, FileNotFoundException, IOException{
		myBar = new Bar();
		myEngine = engine;
		myModel = m;
	}

public MainPanel(GameEngine engine, Model m, String s, int i) throws UnsupportedEncodingException, FileNotFoundException, IOException{

		myEngine = engine;
		myModel = m;
		myTempInt = i;
	}

private void addImage(int id, String imageString){
	ImageMap.put(id, imageString);
	file+= String.valueOf(id) + " " + imageString + "\n";
}

private void readImageFile(File file){
	try{
	Scanner scanner = new Scanner(file);
	while(scanner.hasNext()){
		addImage(scanner.nextInt(), scanner.next());
		if(scanner.hasNext())
			scanner.nextLine();
}
	scanner.close();
} catch (FileNotFoundException e) {
	e.printStackTrace();
}
}

/**
 * Create the different Panels , TabbedPanes and ScrollPanes necessary to construct the GAE
 * @param s
 * @throws UnsupportedEncodingException
 * @throws FileNotFoundException
 * @throws IOException
 */
	public void edit(String s) throws UnsupportedEncodingException, FileNotFoundException, IOException{

		readImageFile(new File(IMAGE_FILE));

		System.out.println("THE EDIT FILE WAS RUN ");
		if (myTempInt!=2) {
			if (s != null) {
				System.out.println("s is " + s);
				data = new DataFile(s);
				if (data.fileExistCheck()) {
					if(data.readModel() != null){
						myModel = data.readModel();
						myModel.setIdentifier(s);
						System.out.println("model has " + myModel.getAllLevels().size() + " levels");
						myEngine.loadGame(myModel);
						//myEngine.setBar(myBar);

					}
				} else {
					System.out.println("a file had to be made");
					//this means that there is no existing game with the name s
					myModel = data.getTemporaryModel();
					System.out.println("model has " + myModel.getAllLevels().size() + " levels");
					myEngine.loadGame(myModel);
					//myEngine.setBar(myBar);
				}
			}

			pane = new JTabbedPane();
			new ButtonHandler(pane, "New Level", myModel);
			for(int i = 1; i< myModel.getAllLevels().size()+1; i++){
				GameDisplay newDisplay = new GameDisplay(800, 600);
				pane.addTab("level " + i, newDisplay);
			}
			isFirstRun = true;

			pane.addChangeListener(new ChangeListener()
		    {
			/**
			 * The Change Listener here is for the tabs of pane. When the user switches between
			 * different level displays in pane, this change listener makes sure that the objects
			 * in the engine for the particular level are destroyed and replaced by the objects for
			 * the other level. The authoring environment and the engine should both be up to date.
			 *
			 */
		      public void stateChanged(ChangeEvent e)
		     {

		    	  if (pane.getSelectedIndex() > 0 && isFirstRun==false) {
		    		  //ENGINE: Destroy current level inside the engine
		    		  if (myEngine.getMyMovingObjects().size() > 0) {
		    			  for (JGObject j : myEngine.getMyMovingObjects()) {
		    				  j.remove();
		    			  }
		    		  }

		    		  if (myEngine.getMyStillObjects().size() > 0 ) {
		    			  for (JGObject j : myEngine.getMyStillObjects()) {
		    				  j.remove();
		    			  }
		    		  }
		    		  //Level levelToDestroy = myModel.getAllLevels().get(myModel.getCurrentLevelIndex());
		    		  //System.out.println("player count is " + levelToDestroy.getAllPlayers().size());
		    		  //myModel.destroyLevel(levelToDestroy);
		    		  myModel.setCurrentLevelIndex(pane.getSelectedIndex()-1);
		    		  /*
		    		  data = new DataFile(myModel.getIdentifier());
		    		  try {
						myModel = data.readModel();
					} catch (UnsupportedEncodingException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					} catch (IOException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					} catch (NullPointerException e1) {
						//
					}
		    		  */
		    		  myEngine.loadGame(myModel);

		    		  // TODO: load everything into the authoring view
		    		  System.out.print("hi" + pane.getSelectedIndex());

		    		  //Save positions of all objects on level

		    		  //clear engine
		    		  // create new variable to level
		    		  // myEngine.clearGameState();

		    		  //clear offset

		    		  //load engine

		    	  }

		    	  GameDisplay gd = (GameDisplay) pane.getSelectedComponent();

					for (MovingObject p: myEngine.getMyMovingObjects()) {
						System.out.println(p.getMyImageIndex());
						 String imgLoc = ImageMap.get(p.getMyImageIndex());
			    		  BufferedImage image = null;
							try {
								image = ImageIO.read(new File(imgLoc));
							} catch (IOException g) {
								// TODO Auto-generated catch block
								g.printStackTrace();
							}
							if (p instanceof Player) {
								Player q = (Player) p;
								if (q.myImage!=null) {
									System.out.println("CCCC");
									q.myImage.setImage(image);
								} else {
								q.myImage = gd.addMoveableImage(image, (int)q.getLastX(), (int)q.getLastY());

								}
							} else if (p instanceof Enemy) {
								Enemy q = (Enemy) p;
								if (q.myImage!=null) {
									System.out.println("CCCC");
									q.myImage.setImage(image);
								} else {
								q.myImage = gd.addMoveableImage(image, (int)q.getLastX(), (int)q.getLastY());

								}
							}
					}

					for (JGObject p: myEngine.getMyStillObjects()) {
						 String imgLoc = ImageMap.get(p.getMyImageIndex());
			    		  BufferedImage image = null;
							try {
								image = ImageIO.read(new File(imgLoc));
							} catch (IOException g) {
								// TODO Auto-generated catch block
								g.printStackTrace();
							}
							if (p instanceof Coin) {
								Coin q = (Coin) p;
								if (q.myImage!=null) {
									System.out.println("CCCC");
									q.myImage.setImage(image);
								} else {
								q.myImage = gd.addMoveableImage(image, (int)q.getLastX(), (int)q.getLastY());

								}
							} else if (p instanceof LevelEndObject) {
								LevelEndObject q = (LevelEndObject) p;
								if (q.myImage!=null) {
									System.out.println("CCCC");
									q.myImage.setImage(image);
								} else {
								q.myImage = gd.addMoveableImage(image, (int)q.getLastX(), (int)q.getLastY());

								}
							} else if (p instanceof Platform) {
								//TODO: load platforms straight into the MainPanel as well.
							}
					}

		    	  isFirstRun = false;
		      }
		    });
		//this.setLayout(new BoxLayout(this, BoxLayout.X_AXIS));

//		BetterTabbedPane pane = new BetterTabbedPane();
//>>>>>>> 98b4f464da6845d47831d278ce71dd6f9558f0a2

		//THIS MUST BE setPrefferedSize, others don't work
		//THIS IS WHERE USER PREFERENCE GOES
		/*
		JTextField xField = new JTextField(5);
		JTextField yField = new JTextField(5);

		JPanel myPanel = new JPanel();
		myPanel.add(new JLabel("Width:"));
		myPanel.add(xField);
		myPanel.add(Box.createHorizontalStrut(15)); // a spacer
		myPanel.add(new JLabel("Height:"));
		myPanel.add(yField);

		//need to control inputs here because the engine needs to have the same PFWidth and worldsize as the current
		//authoring environment so that things go in the right place
		JOptionPane.showConfirmDialog(null, myPanel,
				"SET TO 3600, 700 TO KEEP ENGINE AS IS" +
				 " Please Enter The Height And Width Values For Your Game ", JOptionPane.OK_CANCEL_OPTION);

		*/

		//int widthOfPane = Integer.parseInt(xField.getText());
		//int heightOfPane = Integer.parseInt(yField.getText());
		//this size will need to be recorded in JSON to reload games
		//this is risky
		//this isnt that risky, it just means we need to store and reload all objects inside the new world if we want to keep them
		//myEngine.setSizeOfPF(widthOfPane, heightOfPane);

		//pass in size

			/*
			JTextField xField = new JTextField(5);
			JTextField yField = new JTextField(5);
=======
		//	JTextField xField = new JTextField(5);
			//JTextField yField = new JTextField(5);
>>>>>>> e4641d93a67cfad073d119c23733e2fa389a9c7b

			//JPanel myPanel = new JPanel();
			//myPanel.add(new JLabel("Width:"));
			//myPanel.add(xField);
			//myPanel.add(Box.createHorizontalStrut(15)); // a spacer
			//myPanel.add(new JLabel("Height:"));
			//myPanel.add(yField);

			//need to control inputs here because the engine needs to have the same PFWidth and worldsize as the current
			//authoring environment so that things go in the right place
			//JOptionPane.showConfirmDialog(null, myPanel,
				//	"SET TO 3600, 700 TO KEEP ENGINE AS IS" +
					//		" Please Enter The Height And Width Values For Your Game ", JOptionPane.OK_CANCEL_OPTION);

<<<<<<< HEAD
			int widthOfPane = Integer.parseInt(xField.getText());
			int heightOfPane = Integer.parseInt(yField.getText());
			*/
			//this size will need to be recorded in JSON to reload games
			pane.setPreferredSize(new Dimension(800, 600));
			//this is risky
			//this isnt that risky, it just means we need to store and reload all objects inside the new world if we want to keep them
			//myEngine.setSizeOfPF(widthOfPane, heightOfPane); //COMMENTED OUT

			//pass in size
			//new ButtonHandler(pane, "New Tab");
			//add(new MoveGAEPositionButton(pane, "left"));
			//add(new MoveGAEPositionButton(pane, "right"));
			System.out.println(myEngine + " main panel");

			SettingDisplay mySetDisplay = new SettingDisplay(pane, myModel, myEngine);
			this.add(mySetDisplay);

			SettingPanel mySettings = new SettingPanel(mySetDisplay, myModel, myEngine, pane);
			WorldSettingsPanel myWorldSettings = new WorldSettingsPanel(pane, mySetDisplay, myModel, myEngine);

			JTabbedPane myTabs = new JTabbedPane();
			myTabs.addTab("Objects", mySettings);
			myTabs.setMnemonicAt(0, KeyEvent.VK_1);

			myTabs.addTab("World", myWorldSettings);
			myTabs.setMnemonicAt(1, KeyEvent.VK_2);

			myTabs.addTab("Object Settings", mySetDisplay);
			myTabs.setMnemonicAt(2, KeyEvent.VK_3);

			JScrollPane scrollSettings = new JScrollPane(myTabs, 22, 32);
			scrollSettings.setPreferredSize(new Dimension(500,800));
			scrollSettings.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
			scrollSettings.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
			this.add(scrollSettings);
		//	JScrollPane scrollSetDisplay = new JScrollPane(mySetDisplay, 22, 32);
			//this.add(scrollSetDisplay);
			JPanel rightPanel = new JPanel();
			rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
			CanvasController myCController = new CanvasController(mySetDisplay, mySettings,myModel, myEngine, pane);
			rightPanel.add(myCController);
			JScrollPane scrollingGameDisplay = new JScrollPane(pane);
			scrollingGameDisplay.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);
			scrollingGameDisplay.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
			int x = (int) Toolkit.getDefaultToolkit().getScreenSize().getWidth()-700;
			int y = 600;
			//(int) Toolkit.getDefaultToolkit().getScreenSize().getHeight()-100
			scrollingGameDisplay.setPreferredSize(new Dimension(x,y));
			//THIS DIMENSION HAS NOTHING TO DO WITH SIZE OF INNER DISPLAY WINDOW, ONLY OF AREA TAKEN UP BY THE OUTER WINDOW
			//ONLY ADJUST TO CHANGE LAYOUT, NOT IN RESPONSE TO USER INPUT
			//scrollingGameDisplay.setPreferredSize(new Dimension(600,800));
			rightPanel.add(scrollingGameDisplay);
			this.add(rightPanel);

		} else {
			//nothing, because a name must be specified
			//myModel = new Model();
		}

	}

}


text:
import React from 'react';
import { get } from 'lodash';

import { IExecutionDetailsSectionProps, ExecutionDetailsSection } from 'core/pipeline';
import { PipelineRefList } from 'core/pipeline/config/stages/savePipelines/PipleineRefList';

export class SavePipelinesResultsTab extends React.Component<IExecutionDetailsSectionProps> {
  public static title = 'pipelineUpdates';

  public render() {
    const { stage } = this.props;
    const stageContext = get(stage, ['context'], {}) as any;
    return (
      <ExecutionDetailsSection name={this.props.name} current={this.props.current}>
        <PipelineRefList title="Failed Pipeline Updates" pipelineRefs={stageContext.pipelinesFailedToSave || []} />
        <PipelineRefList title="Created Pipelines" pipelineRefs={stageContext.pipelinesCreated || []} />
        <PipelineRefList title="Updated Pipelines" pipelineRefs={stageContext.pipelinesUpdated || []} />
      </ExecutionDetailsSection>
    );
  }
}


text:
import { Observable } from '../../Observable';
import { timeoutWith, TimeoutWithSignature } from '../../operator/timeoutWith';

Observable.prototype.timeoutWith = timeoutWith;

declare module '../../Observable' {
  interface Observable<T> {
    timeoutWith: TimeoutWithSignature<T>;
  }
}


text:
cd "$(dirname "${BASH_SOURCE[0]}")" || exit 1

PGVER=$(psql -d "$2" -XtAc "SELECT pg_catalog.current_setting('server_version_num')::int/10000")
if [ "$PGVER" -ge 12 ]; then RESET_ARGS="oid, oid, bigint"; fi

(echo "DO \$\$
BEGIN
    PERFORM * FROM pg_catalog.pg_authid WHERE rolname = 'admin';
    IF FOUND THEN
        ALTER ROLE admin WITH CREATEDB NOLOGIN NOCREATEROLE NOSUPERUSER NOREPLICATION INHERIT;
    ELSE
        CREATE ROLE admin CREATEDB;
    END IF;

    PERFORM * FROM pg_catalog.pg_authid WHERE rolname = 'cron_admin';
    IF FOUND THEN
        ALTER ROLE cron_admin WITH NOCREATEDB NOLOGIN NOCREATEROLE NOSUPERUSER NOREPLICATION INHERIT;
    ELSE
        CREATE ROLE cron_admin;
    END IF;
END;\$\$;

GRANT cron_admin TO admin;

DO \$\$
BEGIN
    PERFORM * FROM pg_catalog.pg_authid WHERE rolname = '$1';
    IF FOUND THEN
        ALTER ROLE $1 WITH NOCREATEDB NOLOGIN NOCREATEROLE NOSUPERUSER NOREPLICATION INHERIT;
    ELSE
        CREATE ROLE $1;
    END IF;
END;\$\$;

DO \$\$
BEGIN
    PERFORM * FROM pg_catalog.pg_authid WHERE rolname = 'robot_zmon';
    IF FOUND THEN
        ALTER ROLE robot_zmon WITH NOCREATEDB NOLOGIN NOCREATEROLE NOSUPERUSER NOREPLICATION INHERIT;
    ELSE
        CREATE ROLE robot_zmon;
    END IF;
END;\$\$;

CREATE EXTENSION IF NOT EXISTS pg_auth_mon SCHEMA public;
ALTER EXTENSION pg_auth_mon UPDATE;
GRANT SELECT ON TABLE public.pg_auth_mon TO robot_zmon;

CREATE EXTENSION IF NOT EXISTS pg_cron SCHEMA public;
DO \$\$
BEGIN
    PERFORM 1 FROM pg_catalog.pg_proc WHERE pronamespace = 'cron'::pg_catalog.regnamespace AND proname = 'schedule' AND proargnames = '{p_schedule,p_database,p_command}';
    IF FOUND THEN
        ALTER FUNCTION cron.schedule(text, text, text) RENAME TO schedule_in_database;
    END IF;
END;\$\$;
ALTER EXTENSION pg_cron UPDATE;

ALTER POLICY cron_job_policy ON cron.job USING (username = current_user OR
    (pg_has_role(current_user, 'cron_admin', 'MEMBER')
    AND pg_has_role(username, 'cron_admin', 'MEMBER')
    AND NOT EXISTS(SELECT 1 FROM pg_roles WHERE rolname = username AND rolsuper)
    ));
REVOKE SELECT ON cron.job FROM admin, public;
GRANT SELECT ON cron.job TO cron_admin;
REVOKE UPDATE (database, nodename) ON cron.job FROM admin;
GRANT UPDATE (database, nodename) ON cron.job TO cron_admin;

ALTER POLICY cron_job_run_details_policy ON cron.job_run_details USING (username = current_user OR
    (pg_has_role(current_user, 'cron_admin', 'MEMBER')
    AND pg_has_role(username, 'cron_admin', 'MEMBER')
    AND NOT EXISTS(SELECT 1 FROM pg_roles WHERE rolname = username AND rolsuper)
    ));
REVOKE SELECT ON cron.job_run_details FROM admin, public;
GRANT SELECT ON cron.job_run_details TO cron_admin;

CREATE OR REPLACE FUNCTION cron.schedule_in_database(p_schedule text, p_database text, p_command text)
RETURNS bigint
LANGUAGE plpgsql
AS \$function\$
DECLARE
    l_jobid bigint;
BEGIN
    IF NOT (SELECT rolcanlogin FROM pg_roles WHERE rolname = current_user)
    THEN RAISE 'You cannot create a job using a role that cannot log in';
    END IF;

    SELECT schedule INTO l_jobid FROM cron.schedule(p_schedule, p_command);
    UPDATE cron.job SET database = p_database, nodename = '' WHERE jobid = l_jobid;
    RETURN l_jobid;
END;
\$function\$;
REVOKE EXECUTE ON FUNCTION cron.alter_job(bigint, text, text, text, text, boolean) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.alter_job(bigint, text, text, text, text, boolean) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.schedule(text, text) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.schedule(text, text) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.schedule(text, text, text) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.schedule(text, text, text) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.schedule_in_database(text, text, text) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.schedule_in_database(text, text, text) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.schedule_in_database(text, text, text, text, text, boolean) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.schedule_in_database(text, text, text, text, text, boolean) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.unschedule(bigint) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.unschedule(bigint) TO cron_admin;
REVOKE EXECUTE ON FUNCTION cron.unschedule(name) FROM admin, public;
GRANT EXECUTE ON FUNCTION cron.unschedule(name) TO cron_admin;
REVOKE USAGE ON SCHEMA cron FROM admin;
GRANT USAGE ON SCHEMA cron TO cron_admin;

CREATE EXTENSION IF NOT EXISTS file_fdw SCHEMA public;
DO \$\$
BEGIN
    PERFORM * FROM pg_catalog.pg_foreign_server WHERE srvname = 'pglog';
    IF NOT FOUND THEN
        CREATE SERVER pglog FOREIGN DATA WRAPPER file_fdw;
    END IF;
END;\$\$;

CREATE TABLE IF NOT EXISTS public.postgres_log (
    log_time timestamp(3) with time zone,
    user_name text,
    database_name text,
    process_id integer,
    connection_from text,
    session_id text NOT NULL,
    session_line_num bigint NOT NULL,
    command_tag text,
    session_start_time timestamp with time zone,
    virtual_transaction_id text,
    transaction_id bigint,
    error_severity text,
    sql_state_code text,
    message text,
    detail text,
    hint text,
    internal_query text,
    internal_query_pos integer,
    context text,
    query text,
    query_pos integer,
    location text,
    application_name text,
    CONSTRAINT postgres_log_check CHECK (false) NO INHERIT
);
GRANT SELECT ON public.postgres_log TO admin;"
if [ "$PGVER" -ge 13 ]; then
    echo "ALTER TABLE public.postgres_log ADD COLUMN IF NOT EXISTS backend_type text;"
fi
if [ "$PGVER" -ge 14 ]; then
    echo "ALTER TABLE public.postgres_log ADD COLUMN IF NOT EXISTS leader_pid integer;"
    echo "ALTER TABLE public.postgres_log ADD COLUMN IF NOT EXISTS query_id bigint;"
fi

# Sunday could be 0 or 7 depending on the format, we just create both
for i in $(seq 0 7); do
    echo "CREATE FOREIGN TABLE IF NOT EXISTS public.postgres_log_$i () INHERITS (public.postgres_log) SERVER pglog
    OPTIONS (filename '../pg_log/postgresql-$i.csv', format 'csv', header 'false');
GRANT SELECT ON public.postgres_log_$i TO admin;

CREATE OR REPLACE VIEW public.failed_authentication_$i WITH (security_barrier) AS
SELECT *
  FROM public.postgres_log_$i
 WHERE command_tag = 'authentication'
   AND error_severity = 'FATAL';
ALTER VIEW public.failed_authentication_$i OWNER TO postgres;
GRANT SELECT ON TABLE public.failed_authentication_$i TO robot_zmon;
"
done

cat _zmon_schema.dump

while IFS= read -r db_name; do
    echo "\c ${db_name}"
    # In case if timescaledb binary is missing the first query fails with the error
    # ERROR:  could not access file "$libdir/timescaledb-$OLD_VERSION": No such file or directory
    UPGRADE_TIMESCALEDB=$(echo -e "SELECT NULL;\nSELECT default_version != installed_version FROM pg_catalog.pg_available_extensions WHERE name = 'timescaledb'" | psql -tAX -d "${db_name}" 2> /dev/null | tail -n 1)
    if [ "$UPGRADE_TIMESCALEDB" = "t" ]; then
        echo "ALTER EXTENSION timescaledb UPDATE;"
    fi
    UPGRADE_POSTGIS=$(echo -e "SELECT COUNT(*) FROM pg_catalog.pg_extension WHERE extname = 'postgis'" | psql -tAX -d "${db_name}" 2> /dev/null | tail -n 1)
    if [ "$UPGRADE_POSTGIS" = "1" ]; then
        # public.postgis_lib_version() is available only if postgis extension is created
        UPGRADE_POSTGIS=$(echo -e "SELECT extversion != public.postgis_lib_version() FROM pg_catalog.pg_extension WHERE extname = 'postgis'" | psql -tAX -d "${db_name}" 2> /dev/null | tail -n 1)
        if [ "$UPGRADE_POSTGIS" = "t" ]; then
            echo "ALTER EXTENSION postgis UPDATE;"
            echo "SELECT public.postgis_extensions_upgrade();"
        fi
    fi
    sed "s/:HUMAN_ROLE/$1/" create_user_functions.sql
    echo "CREATE EXTENSION IF NOT EXISTS pg_stat_statements SCHEMA public;
CREATE EXTENSION IF NOT EXISTS pg_stat_kcache SCHEMA public;
CREATE EXTENSION IF NOT EXISTS set_user SCHEMA public;
ALTER EXTENSION set_user UPDATE;
GRANT EXECUTE ON FUNCTION public.set_user(text) TO admin;
GRANT EXECUTE ON FUNCTION public.pg_stat_statements_reset($RESET_ARGS) TO admin;"
    if [ "$PGVER" -lt 10 ]; then
        echo "GRANT EXECUTE ON FUNCTION pg_catalog.pg_switch_xlog() TO admin;"
    else
        echo "GRANT EXECUTE ON FUNCTION pg_catalog.pg_switch_wal() TO admin;"
    fi
    if [ "$ENABLE_PG_MON" = "true" ] && [ "$PGVER" -ge 11 ]; then echo "CREATE EXTENSION IF NOT EXISTS pg_mon SCHEMA public;"; fi
    cat metric_helpers.sql
done < <(psql -d "$2" -tAc 'select pg_catalog.quote_ident(datname) from pg_catalog.pg_database where datallowconn')
) | PGOPTIONS="-c synchronous_commit=local" psql -Xd "$2"


text:
<!-- start custom head snippets -->

<!-- insert favicons. use http://realfavicongenerator.net/ -->

<link rel="apple-touch-icon" sizes="180x180" href="{{ site.url }}{{ site.baseurl }}/assets/favicons/apple-touch-icon.png">
<link rel="icon" type="image/png" href="{{ site.url }}{{ site.baseurl }}/assets/favicons/favicon-32x32.png" sizes="32x32">
<link rel="icon" type="image/png" href="{{ site.url }}{{ site.baseurl }}/assets/favicons/favicon-16x16.png" sizes="16x16">
<link rel="manifest" href="{{ site.url }}{{ site.baseurl }}/assets/favicons/manifest.json">
<link rel="mask-icon" href="{{ site.url }}{{ site.baseurl }}/assets/favicons/safari-pinned-tab.svg" color="#5bbad5">
<meta name="theme-color" content="#ffffff">

<!-- end custom head snippets -->


text:
package org.mitre.stix;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Define a version annotation
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PACKAGE)
public @interface Version {
	String schema();
}


text:
namespace pp {

class Instance;

// Typical usage:
//
//   // Create an audio config with a supported frame count.
//   uint32_t sample_frame_count = AudioConfig::RecommendSampleFrameCount(
//       PP_AUDIOSAMPLERATE_44100, 4096);
//   AudioConfig config(PP_AUDIOSAMPLERATE_44100, sample_frame_count);
//   if (config.is_null())
//     return false;  // Couldn't configure audio.
//
//   // Then use the config to create your audio resource.
//   Audio audio(..., config, ...);
//   if (audio.is_null())
//     return false;  // Couldn't create audio.
class AudioConfig : public Resource {
 public:
  AudioConfig();

  // Creates an audio config based on the given sample rate and frame count.
  // If the rate and frame count aren't supported, the resulting resource
  // will be is_null(). Pass the result of RecommendSampleFrameCount as the
  // sample frame count.
  //
  // See PPB_AudioConfig.CreateStereo16Bit for more.
  AudioConfig(Instance* instance,
              PP_AudioSampleRate sample_rate,
              uint32_t sample_frame_count);

  // Returns a supported frame count for use in the constructor.
  //
  // See PPB_AudioConfig.RecommendSampleFrameCount.
  static uint32_t RecommendSampleFrameCount(
      PP_AudioSampleRate sample_rate,
      uint32_t requested_sample_frame_count);

  PP_AudioSampleRate sample_rate() const { return sample_rate_; }
  uint32_t sample_frame_count() { return sample_frame_count_; }

 private:
  PP_AudioSampleRate sample_rate_;
  uint32_t sample_frame_count_;
};

}  // namespace pp

#endif  // PPAPI_CPP_AUDIO_CONFIG_H_


text:
package com.blazebit.persistence.view.testsuite.update.subview.multiparent.selfreferential.model;

import com.blazebit.persistence.testsuite.entity.Person;
import com.blazebit.persistence.view.CreatableEntityView;
import com.blazebit.persistence.view.EntityView;
import com.blazebit.persistence.view.UpdatableEntityView;

/**
 *
 * @author Christian Beikov
 * @since 1.3.0
 */
@CreatableEntityView
@UpdatableEntityView
@EntityView(Person.class)
public interface UpdatablePersonView extends PersonView {

    public void setName(String name);

    public PersonView getFriend();

    public void setFriend(PersonView friend);

}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
A. Guillemin et al. , Fl. Seneg. tent. 1: t. 55. 1832 Jul; 242. 1832 Oct

#### Original name
null

### Remarks
null


text:
define(function(require, exports, module) {

exports.isDark = true;
exports.cssClass = "ace--revelation";
exports.cssText = require("../requirejs/text!./Revelation.css");

var dom = require("../lib/dom");
dom.importCssString(exports.cssText, exports.cssClass);
});


text:
import isSameMonth from 'date-fns/isSameMonth';
import isEqual from 'lodash/isEqual';
import omit from 'lodash/omit';

import type { State } from '../types';

import type { NetWorthEntryNative } from '~client/types';
import { coalesceKeys, omitDeep } from '~shared/utils';

const getCompareState = (state: State): Record<string, unknown> => ({
  parameters: state.parameters,
  accounts: state.accounts.map((account) =>
    omitDeep(
      {
        ...omit(account, 'computedValues'),
        creditCards: account.creditCards.map((card) => omit(card, 'predictedPayment')),
        values: account.values.map((row) =>
          coalesceKeys(row, 'value', 'formula', 'transferToAccountId'),
        ),
      },
      'id',
    ),
  ),
});

export const isStateEqual = (s0: State, s1: State): boolean =>
  isEqual(getCompareState(s0), getCompareState(s1));

export function filterNetWorthByMonth(
  entries: NetWorthEntryNative[],
  date: Date,
): NetWorthEntryNative | undefined {
  return entries.find((entry) => isSameMonth(entry.date, date));
}


text:
@implementation DataAccessor

+ (DataAccessor *)sharedAccessor {
    static DataAccessor *sharedAccessor;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedAccessor = [[DataAccessor alloc] init];
    });
    return sharedAccessor;
}

- (NSFetchedResultsController *)fetchedResultsControllerForObject:(NSString *)object withPredicate:(NSPredicate *)predicate sortDescriptors:(NSArray *)descriptors {
    NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:object];
    request.sortDescriptors = descriptors;
    request.predicate = predicate;

    NSFetchedResultsController *controller = [[NSFetchedResultsController alloc] initWithFetchRequest:request
                                                                                managedObjectContext:[CoreDataHelper getContext]
                                                                                sectionNameKeyPath:nil cacheName:nil];
    return controller;
}

- (NSFetchedResultsController *)contactsFetchedResultsController {
    NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:@"Contact"];
    request.sortDescriptors = @[ [NSSortDescriptor sortDescriptorWithKey:@"lastName" ascending:YES] ];

    NSFetchedResultsController *controller = [[NSFetchedResultsController alloc] initWithFetchRequest:request
                                                                                managedObjectContext:[CoreDataHelper getContext] sectionNameKeyPath:nil cacheName:nil];
    return controller;
}

- (NSArray *)getActivitiesSatisfyingPredicate:(NSPredicate *)predicate {
    NSArray *activityTypes = @[ @"Task", @"PhoneCall", @"Appointment" ];

    NSMutableArray *retVal = [NSMutableArray array];
    for (NSString *typeName in activityTypes) {
        NSFetchRequest *request = [NSFetchRequest fetchRequestWithEntityName:typeName];
        request.predicate = predicate;

        NSError *fetchError = nil;
        NSArray *objects = [[CoreDataHelper getContext] executeFetchRequest:request error:&fetchError];
        if (!objects) {
            NSLog(@"Error fetching objects of type %@ : %@\n%@", typeName, fetchError.localizedDescription, fetchError.localizedFailureReason);
        }
        [retVal addObjectsFromArray:objects];
    }
    return [retVal copy];
}

@end