text:
package com.softeem.orderapp.utils;

/**
 * Created by 王致尧 on 2017/6/29.
 */

public interface UserService {
    String getPassword(String username);
}


text:
require 'slack'

require "humanized_slack_api/api_root"
require "humanized_slack_api/channel"
require "humanized_slack_api/user"
require "humanized_slack_api/version"

module HumanizedSlackApi
  def self.api_root(token)
    HumanizedSlackApi::ApiRoot.new(token)
  end
end

redpajama_set_name: RedPajamaGithub


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Runtime;
using System.Threading;
using System.Threading.Tasks;
using System.Globalization;
using Microsoft.CodeAnalysis.CommandLine;

namespace Microsoft.CodeAnalysis.CompilerServer
{
    internal interface IClientConnectionHost
    {
        Task<IClientConnection> CreateListenTask(CancellationToken cancellationToken);
    }

    /// <summary>
    /// This class manages the connections, timeout and general scheduling of the client
    /// requests.
    /// </summary>
    internal sealed class ServerDispatcher
    {
        private enum State
        {
            /// <summary>
            /// Server running and accepting all requests
            /// </summary>
            Running,

            /// <summary>
            /// Server processing existing requests, responding to shutdown commands but is not accepting
            /// new build requests.
            /// </summary>
            ShuttingDown,

            /// <summary>
            /// Server is done.
            /// </summary>
            Completed,
        }

        /// <summary>
        /// Default time the server will stay alive after the last request disconnects.
        /// </summary>
        internal static readonly TimeSpan DefaultServerKeepAlive = TimeSpan.FromMinutes(10);

        /// <summary>
        /// Time to delay after the last connection before initiating a garbage collection
        /// in the server.
        /// </summary>
        internal static readonly TimeSpan GCTimeout = TimeSpan.FromSeconds(30);

        private readonly IClientConnectionHost _clientConnectionHost;
        private readonly IDiagnosticListener _diagnosticListener;
        private State _state;
        private Task _timeoutTask;
        private Task _gcTask;
        private Task<IClientConnection> _listenTask;
        private CancellationTokenSource _listenCancellationTokenSource;
        private List<Task<ConnectionData>> _connectionList = new List<Task<ConnectionData>>();
        private TimeSpan? _keepAlive;
        private bool _keepAliveIsDefault;

        internal ServerDispatcher(IClientConnectionHost clientConnectionHost, IDiagnosticListener diagnosticListener = null)
        {
            _clientConnectionHost = clientConnectionHost;
            _diagnosticListener = diagnosticListener ?? new EmptyDiagnosticListener();
        }

        /// <summary>
        /// This function will accept and process new connections until an event causes
        /// the server to enter a passive shut down mode.  For example if analyzers change
        /// or the keep alive timeout is hit.  At which point this function will cease
        /// accepting new connections and wait for existing connections to complete before
        /// returning.
        /// </summary>
        public void ListenAndDispatchConnections(TimeSpan? keepAlive, CancellationToken cancellationToken = default(CancellationToken))
        {
            _state = State.Running;
            _keepAlive = keepAlive;
            _keepAliveIsDefault = true;

            try
            {
                ListenAndDispatchConnectionsCore(cancellationToken);
            }
            finally
            {
                _state = State.Completed;
                _gcTask = null;
                _timeoutTask = null;

                if (_listenTask != null)
                {
                    CloseListenTask();
                }
            }
        }

        public void ListenAndDispatchConnectionsCore(CancellationToken cancellationToken)
        {
            CreateListenTask();
            do
            {
                Debug.Assert(_listenTask != null);

                MaybeCreateTimeoutTask();
                MaybeCreateGCTask();
                WaitForAnyCompletion(cancellationToken);
                CheckCompletedTasks(cancellationToken);
            } while (_connectionList.Count > 0 || _state == State.Running);
        }

        private void CheckCompletedTasks(CancellationToken cancellationToken)
        {
            if (cancellationToken.IsCancellationRequested)
            {
                HandleCancellation();
                return;
            }

            if (_listenTask.IsCompleted)
            {
                HandleCompletedListenTask(cancellationToken);
            }

            if (_timeoutTask?.IsCompleted == true)
            {
                HandleCompletedTimeoutTask();
            }

            if (_gcTask?.IsCompleted == true)
            {
                HandleCompletedGCTask();
            }

            HandleCompletedConnections();
        }

        private void HandleCancellation()
        {
            Debug.Assert(_listenTask != null);

            // If cancellation has been requested then the server needs to be in the process
            // of shutting down.
            _state = State.ShuttingDown;

            CloseListenTask();

            try
            {
                Task.WaitAll(_connectionList.ToArray());
            }
            catch
            {
                // It's expected that some will throw exceptions, in particular OperationCanceledException.  It's
                // okay for them to throw so long as they complete.
            }

            HandleCompletedConnections();
            Debug.Assert(_connectionList.Count == 0);
        }

        /// <summary>
        /// The server farms out work to Task values and this method needs to wait until at least one of them
        /// has completed.
        /// </summary>
        private void WaitForAnyCompletion(CancellationToken cancellationToken)
        {
            var all = new List<Task>();
            all.AddRange(_connectionList);
            all.Add(_timeoutTask);
            all.Add(_listenTask);
            all.Add(_gcTask);

            try
            {
                var waitArray = all.Where(x => x != null).ToArray();
                Task.WaitAny(waitArray, cancellationToken);
            }
            catch (OperationCanceledException)
            {
                // Thrown when the provided cancellationToken is cancelled.  This is handled in the caller,
                // here it just serves to break out of the WaitAny call.
            }
        }

        private void CreateListenTask()
        {
            Debug.Assert(_listenTask == null);
            Debug.Assert(_timeoutTask == null);
            _listenCancellationTokenSource = new CancellationTokenSource();
            _listenTask = _clientConnectionHost.CreateListenTask(_listenCancellationTokenSource.Token);
            _diagnosticListener.ConnectionListening();
        }

        private void CloseListenTask()
        {
            Debug.Assert(_listenTask != null);

            _listenCancellationTokenSource.Cancel();
            _listenCancellationTokenSource = null;
            _listenTask = null;
        }

        private void HandleCompletedListenTask(CancellationToken cancellationToken)
        {
            _diagnosticListener.ConnectionReceived();
            var allowCompilationRequests = _state == State.Running;
            var connectionTask = HandleClientConnection(_listenTask, allowCompilationRequests, cancellationToken);
            _connectionList.Add(connectionTask);

            // Timeout and GC are only done when there are no active connections.  Now that we have a new
            // connection cancel out these tasks.
            _timeoutTask = null;
            _gcTask = null;

            // Begin listening again for new connections.
            _listenTask = null;
            CreateListenTask();
        }

        private void HandleCompletedTimeoutTask()
        {
            _diagnosticListener.KeepAliveReached();
            _listenCancellationTokenSource.Cancel();
            _timeoutTask = null;
            _state = State.ShuttingDown;
        }

        private void HandleCompletedGCTask()
        {
            _gcTask = null;
            for (int i = 0; i < 10; i++)
            {
                GC.Collect();
                GC.WaitForPendingFinalizers();
            }
            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
            GC.Collect();
        }

        private void MaybeCreateTimeoutTask()
        {
            // If there are no active clients running then the server needs to be in a timeout mode.
            if (_connectionList.Count == 0 && _timeoutTask == null && _keepAlive.HasValue)
            {
                Debug.Assert(_listenTask != null);
                _timeoutTask = Task.Delay(_keepAlive.Value);
            }
        }

        private void MaybeCreateGCTask()
        {
            if (_connectionList.Count == 0 && _gcTask == null)
            {
                _gcTask = Task.Delay(GCTimeout);
            }
        }

        /// <summary>
        /// Checks the completed connection objects.
        /// </summary>
        /// <returns>False if the server needs to begin shutting down</returns>
        private void HandleCompletedConnections()
        {
            var shutdown = false;
            var processedCount = 0;
            var i = 0;
            while (i < _connectionList.Count)
            {
                var current = _connectionList[i];
                if (!current.IsCompleted)
                {
                    i++;
                    continue;
                }

                _connectionList.RemoveAt(i);
                processedCount++;

                var connectionData = current.Result;
                ChangeKeepAlive(connectionData.KeepAlive);

                switch (connectionData.CompletionReason)
                {
                    case CompletionReason.CompilationCompleted:
                    case CompletionReason.CompilationNotStarted:
                        // These are all normal shutdown states.  Nothing to do here.
                        break;
                    case CompletionReason.ClientDisconnect:
                        // Have to assume the worst here which is user pressing Ctrl+C at the command line and
                        // hence wanting all compilation to end.
                        shutdown = true;
                        break;
                    case CompletionReason.ClientException:
                    case CompletionReason.ClientShutdownRequest:
                        shutdown = true;
                        break;
                    default:
                        throw new InvalidOperationException($"Unexpected enum value {connectionData.CompletionReason}");
                }

                _diagnosticListener.ConnectionCompleted(connectionData.CompletionReason);
            }

            if (shutdown)
            {
                _state = State.ShuttingDown;
            }
        }

        private void ChangeKeepAlive(TimeSpan? value)
        {
            if (value.HasValue)
            {
                if (_keepAliveIsDefault || !_keepAlive.HasValue || value.Value > _keepAlive.Value)
                {
                    _keepAlive = value;
                    _keepAliveIsDefault = false;
                    _diagnosticListener.UpdateKeepAlive(value.Value);
                }
            }
        }

        /// <summary>
        /// Creates a Task representing the processing of the new connection.  This will return a task that
        /// will never fail.  It will always produce a <see cref="ConnectionData"/> value.  Connection errors
        /// will end up being represented as <see cref="CompletionReason.ClientDisconnect"/>
        /// </summary>
        internal static async Task<ConnectionData> HandleClientConnection(Task<IClientConnection> clientConnectionTask, bool allowCompilationRequests = true, CancellationToken cancellationToken = default(CancellationToken))
        {
            IClientConnection clientConnection;
            try
            {
                clientConnection = await clientConnectionTask.ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                // Unable to establish a connection with the client.  The client is responsible for
                // handling this case.  Nothing else for us to do here.
                CompilerServerLogger.LogException(ex, "Error creating client named pipe");
                return new ConnectionData(CompletionReason.CompilationNotStarted);
            }

            try
            {
                return await clientConnection.HandleConnection(allowCompilationRequests, cancellationToken).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                CompilerServerLogger.LogException(ex, "Error handling connection");
                return new ConnectionData(CompletionReason.ClientException);
            }
        }
    }
}


text:
@protocol KLsuggestionViewDelegate <NSObject>

@optional

-(void)submitWithContent:(NSString *)content andPhone:(NSString *)phone;

@end

@interface KLSuggestionView : UIView
@property (weak, nonatomic) IBOutlet UITextField *phoneTextField;
@property (weak, nonatomic) IBOutlet UIButton *submitBtn;
- (IBAction)submitBtnClick:(id)sender;
@property (weak, nonatomic) IBOutlet UILabel *placeHolderLabel;
@property (weak, nonatomic) IBOutlet UITextView *contentView;

@property(weak,nonatomic)id<KLsuggestionViewDelegate>delegate;

+(instancetype)initView;

-(void)setUI;

@end


text:
Contact Me

 Twitter: ms_ellerz

 Github: sunsplat

 Email: ms.esun@gmail.com

Mobile: 678-860-7840

Get in touch

						<form id="contact-form" role="form" novalidate="">

								Name
								<input type="text" id="name" class="form-control" name="name" placeholder="Name*" required="" data-validation-required-message="Please enter your name.">

								Your Email
								<input type="email" id="email" name="email" class="form-control" placeholder="Your E-mail*" required="" data-validation-required-message="Please enter your email address.">

								<textarea class="form-control" id="message" name="message" rows="7" placeholder="Message*" required="" data-validation-required-message="Please enter your message."></textarea>

								<input type="submit" class="btn btn-block btn-round btn-d" name="Submit">

						</form>


text:
import "config"

import waterfall from "helper/array/waterfall"

import {connect, disconnect} from "./db"
import {start, stop} from "./server"

const exit = (code: number = 0) => waterfall([disconnect, stop])
  .then(() => { process.exit(code) })
  .catch((error: Error) => {
    console.error(error)

    process.exit(1)
  })

;["SIGTERM", "SIGINT"].forEach(signal => process.on(signal, () => exit()))

waterfall([connect, start]).catch(error => {
  console.error(error)

  return exit(1)
})


text:
<?php
$action = filter_var($_REQUEST['action'], FILTER_SANITIZE_STRING);
$ajax = '';
switch($action) {
    case 'fetchProjectsForClient':
        include 'ajax_fetchProjectsForClient.php';
        break;
    case 'fetchProjectsForPostData':
        include 'ajax_fetchProjectsForPostData.php';
        break;
}
echo $ajax;
?>


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

package com.google.devtools.build.lib.buildeventstream;

import java.util.Collection;

/** Wrapper class for a build event marking it as the final event in the protocol. */
public class LastBuildEvent implements BuildEvent {
  private final BuildEvent event;

  public LastBuildEvent(BuildEvent event) {
    this.event = event;
  }

  @Override
  public BuildEventId getEventId() {
    return event.getEventId();
  }

  @Override
  public Collection<BuildEventId> getChildrenEvents() {
    return event.getChildrenEvents();
  }

  @Override
  public Collection<LocalFile> referencedLocalFiles() {
    return event.referencedLocalFiles();
  }

  @Override
  public BuildEventStreamProtos.BuildEvent asStreamProto(BuildEventContext converters) {
    return BuildEventStreamProtos.BuildEvent.newBuilder(event.asStreamProto(converters))
        .setLastMessage(true)
        .build();
  }
}


text:
The Over The Air (OTA) Software Update functionality can be added to any of the
Infineon P6 example applications by passing the `chip_enable_ota_requestor=true`
option to the build script.

## Running the OTA Download scenario

-   An OTA Provider is a node that can respond to the OTA Requestors' queries
    about available software updates and share the update packages with them. An
    OTA Requestor is any node that needs to be updated and can communicate with
    the OTA Provider to fetch applicable software updates. In the procedure
    described below, the OTA Provider will be a Linux application and the
    example running on the Infineon P6 board will work as the OTA Requestor.

-   On a Linux or Darwin platform build the chip-tool and the ota-provider-app
    as follows:

           ```
           scripts/examples/gn_build_example.sh examples/chip-tool out/
           scripts/examples/gn_build_example.sh examples/ota-provider-app/linux out/debug chip_config_network_layer_ble=false
           ```

-   Build the P6 OTA Requestor application from the chip root dir:

          $ ./examples/<example directory>/p6/ota_base_build.sh

-   Build the P6 OTA Update application from the chip root dir:

          $ ./examples/<example directory>/p6/ota_update_build.sh

*   Additionally a pre-compiled bootloader must be flashed to the board using
    [Cypress Programmer](https://softwaretools.infineon.com/tools/com.ifx.tb.tool.cypressprogrammer).
    This image can be found at:

          $ ./third_party/p6/p6_sdk/ota/matter-psoc6-mcuboot-bootloader.hex

*   In a terminal start the Provider app passing to it the path to the Matter
    OTA file created in the previous step:(output of ota_update_build step)

           ```
           rm -r /tmp/chip_*
           ./out/debug/chip-ota-provider-app -f chip-p6-lighting-example.ota
           ```

*   In a separate terminal run the chip-tool commands to provision the Provider:

           ```
           ./out/chip-tool pairing onnetwork 1 20202021
           ./out/chip-tool accesscontrol write acl '[{"fabricIndex": 1, "privilege": 5, "authMode": 2, "subjects": [112233], "targets": null}, {"fabricIndex": 1, "privilege": 3, "authMode": 2, "subjects": null, "targets": null}]' 1 0
           ```

*   If the application device had been previously commissioned press USER Button
    2 to factory-reset the device.

*   In the chip-tool terminal enter:

           ```
           ./out/chip-tool pairing ble-wifi 2 <WIFI_SSID> <WIFI_PASSWORD> 20202021 3840
           ```

*   Once the commissioning process completes enter:

           ```
           ./out/chip-tool otasoftwareupdaterequestor announce-ota-provider 1 0 0 0 2 0
           ```

*   The application device will connect to the Provider and start the image
    download. Status of the transfer can be monitored in the OTA Provider
    terminal. Once the image is downloaded the device will reboot into the
    downloaded image.

In order for the Provider to successfully serve the image to a device during the
OTA Software Update process the softwareVersion parameter in the Provider config
file must be greater than the CHIP_DEVICE_CONFIG_DEVICE_SOFTWARE_VERSION
parameter set in the application's CHIPProjectConfig.h file.


text:
'use strict';

/* Controllers */

var experimentControllers = angular.module('experimentControllers', [])

.factory('experimentFactory', function() {
    var factory = {};
    var customers = [
            { name: 'Dave Jones', city: 'Phoenix' },
            { name: 'Jamie Riley', city: 'Atlanta' },
            { name: 'Heedy Wahlin', city: 'Chandler' },
            { name: 'Thomas Winters', city: 'Seattle' },
        ];
    factory.getCustomers = function() {
        return customers;
    };
    return factory;
})

.controller('ExperimentController', ['$scope', 'experimentFactory',
    function($scope, experimentFactory) {
        $scope.customers = experimentFactory.getCustomers();

        $scope.addCustomer = function () {
            $scope.customers.push({
                name: $scope.newCustomer.name,
                city: $scope.newCustomer.city,
                });
        };
    }
]);


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * Defines broad categories of application errors.
 */
var ErrorCategory = /** @class */ (function () {
    function ErrorCategory() {
    }
    /**
     * Unknown or unexpected errors
     */
    ErrorCategory.Unknown = "Unknown";
    /**
     * Internal errors caused by programming mistakes
     */
    ErrorCategory.Internal = "Internal";
    /**
     * Errors related to mistakes in user-defined configuration
     */
    ErrorCategory.Misconfiguration = "Misconfiguration";
    /**
     * Errors related to operations called in wrong component state.
     * For instance, business calls when component is not ready
     */
    ErrorCategory.InvalidState = "InvalidState";
    /**
     * Errors happened during connection to remote services.
     * They can be related to misconfiguration, network issues
     * or remote service itself
     */
    ErrorCategory.NoResponse = "NoResponse";
    /**
     * Errors returned by remote services or network
     * during call attempts
     */
    ErrorCategory.FailedInvocation = "FailedInvocation";
    /**
     * Errors in read/write file operations
     */
    ErrorCategory.FileError = "FileError";
    /**
     * Errors due to improper user requests, like
     * missing or wrong parameters
     */
    ErrorCategory.BadRequest = "BadRequest";
    /**
     * Access errors caused by missing user identity
     * or security permissions
     */
    ErrorCategory.Unauthorized = "Unauthorized";
    /**
     * Error caused by attempt to access missing object
     */
    ErrorCategory.NotFound = "NotFound";
    /**
     * Errors raised by conflict in object versions
     * posted by user and stored on server.
     */
    ErrorCategory.Conflict = "Conflict";
    /**
     * Errors caused by calls to unsupported
     * or not yet implemented functionality
     */
    ErrorCategory.Unsupported = "Unsupported";
    return ErrorCategory;
}());
exports.ErrorCategory = ErrorCategory;
//# sourceMappingURL=ErrorCategory.js.map


text:
class AddIncludeSasToExports < ActiveRecord::Migration[4.2]
  def change
    add_column :exports, :include_sas, :boolean, null: false, default: false
  end
end


text:
cd $PBS_O_WORKDIR
python rovib.py


text:
// Stack object constructor
function Stack()
{
    this.arrStack = new Array();
    this.intIndex = 0;

    this.Size     = getSize;
    this.IsEmpty  = isStackEmpty;
    this.Push     = pushElement;
    this.Pop      = popElement;
    this.Get      = getElement;
    this.toString = dumpStack;
}

// Converts stack contents into a comma seperated string
function dumpStack()
{
    var intCntr = 0;
    var strRet  =  "";
    if (this.intIndex == 0) return null;
    for (intCntr = 0; intCntr < this.intIndex; intCntr++)
    {
        if (strRet.length == 0)
            strRet += this.arrStack[intCntr];
        else
            strRet += "," + this.arrStack[intCntr];
    }
    return strRet;
}

// Returns size of stack
function getSize()
{
    return this.intIndex;
}

// This method tells us if this Stack object is empty
function isStackEmpty()
{
	if (this.intIndex == 0)
		return true;
	else
		return false;
}

// This method pushes a new element onto the top of the stack
function pushElement(newData)
{
	// Assign our new element to the top
	debugAssert ("Pushing " + newData);
	this.arrStack[this.intIndex] = newData;
	this.intIndex++;
}

// This method pops the top element off of the stack
function popElement()
{
    var retVal;

    retVal = null;
    if (this.intIndex > 0)
    {
	   // Assign our new element to the top
	   this.intIndex--;
	   retVal = this.arrStack[this.intIndex];
	}
	return retVal;
}

// Gets an element at a particular offset from top of the stack
function getElement(intPos)
{
    var retVal;

    //alert ("Size : " + this.intIndex + ", Index " + intPos);
    if (intPos >= 0 && intPos < this.intIndex)
        retVal = this.arrStack[this.intIndex - intPos - 1];
    return retVal;
}


text:
package com.duitang.util.bitbucket.comment.analytic;

import java.util.HashMap;
import java.util.Map;

/**
 * Archive file formats supported by git-archive.
 */
public enum CommentAnalyticFormat {

  TXT("txt");

  private final String extension;

  CommentAnalyticFormat(String extension) {
    this.extension = extension;
  }

  public String getExtension() {
    return extension;
  }

  private static final Map<String, CommentAnalyticFormat> BY_EXTENSTION = new HashMap<>();

  static {
    for (CommentAnalyticFormat format : CommentAnalyticFormat.values()) {
      BY_EXTENSTION.put(format.getExtension(), format);
    }
  }

  public static CommentAnalyticFormat forExtension(String extension) {
    return BY_EXTENSTION.get(extension.toLowerCase());
  }

}


text:
(function (ctx) {

  "use strict";

  var defined = {};
  var exported = {};

  function resolve(from, name) {

    if (name.indexOf('.') === -1) {
      return name;
    }

    name = name.split('/');
    from = from ? from.split('/') : [];
    from.pop();

    if (name[0] === '.') {
      name.shift();
    }

    while(name[0] === '..') {
      name.shift();
      from.pop();
    }

    return from.concat(name).join('/');

  }

  //@TODO handle provide/require/define already in scope

  ctx.provide = function (name, module, isDefinition) {

    if (isDefinition) {
      return defined[name] = module;
    } else {
      return exported[name] = module;
    }

  };

  ctx.require = function (path, canonical) {

    var exports, module;
    var name = canonical || path;

    if (exported[name]) {
      return exported[name];
    } else {

      exports = exported[name] = {};
      module = { exports: exports };
      defined[name](function (path) {
        return ctx.require(path, resolve(name, path));
      }, module, exports);

      return (exported[name] = module.exports);

    }

  };

}(this));

provide('lil_', function (require, module, exports) {

/*jshint curly:true, eqeqeq:true, immed:true, latedef:true,
  newcap:true, noarg:true, sub:true, undef:true, boss:true,
  strict:false, eqnull:true, browser:true, node:true */

module.exports = {

  typeOf: function (x) {

    var type = typeof x;

    if (type === 'object') {
      type = Array.isArray(x) ? 'array' : type;
      type = x === null ? 'null' : type;
    }

    return type;

  },

  each: function (thing, func, ctx) {

    var type = this.typeOf(thing);
    var keys;

    if (type === 'array' && thing.length) {

      thing.forEach(func, ctx);

    } else if (type === 'object') {

      keys = thing ? Object.keys(thing) : [];

      keys.forEach(function (name, i) {
        func.call(ctx, name, thing[name], i);
      });

    }

  },

  every: function (thing, func, ctx) {

    var type = this.typeOf(thing);
    var keys;

    if (type === 'array' && thing.length) {

      return thing.every(func, ctx);

    } else if (type === 'object') {

      keys = thing ? Object.keys(thing) : [];

      return keys.every(function (name, i) {
        return func.call(ctx, name, thing[name], i);
      });

    }

    return false;

  },

  some: function (thing, func, ctx) {

    var type = this.typeOf(thing);
    var keys;

    if (type === 'array' && thing.length) {

      return thing.some(func, ctx);

    } else if (type === 'object') {

      keys = thing ? Object.keys(thing) : [];

      return keys.some(function (name, i) {
        return func.call(ctx, name, thing[name], i);
      });

    }

    return false;

  },

  map: function (thing, func, ctx) {

    var type = this.typeOf(thing);
    var result = [];

    if (type === 'array' && thing.length) {

      return thing.map(func, ctx);

    } else if (type === 'object') {

      result = {};

      this.each(thing, function (name, obj, i) {
        result[name] = func.call(this, name, obj, i);
      }, ctx);

    }

    return result;

  },

  withOut: function (arr, value) {

    var result = [];

    this.each(arr, function (element) {

      if (element !== value) {
        result.push(element);
      }

    });

    return result;

  },

  walk: function (target, source, func, fill) {

    var self = this;

    var walkObj = function (target, source) {

      self.each(source, function (name, obj) {
        step(target[name], obj, name, target);
      });

    };

    var step = function (target, source, name, parent) {

      var type = self.typeOf(source);

      if (type === 'object') {

        if (!target && parent && fill) {
          target = parent[name] = {};
        }

        walkObj(target, source);

      } else {
        func.call(parent, target, source, name);
      }

    };

    step(target, source);

  },

  extend: function () {

    var args = Array.prototype.slice.call(arguments);
    var target = args.shift();

    this.each(args, function (src) {

      this.each(src, function (name, value) {
        target[name] = value;
      });

    }, this);

    return target;

  },

  defaults: function (target, defaults) {

    this.each(defaults, function (name, value) {

      var type = this.typeOf(target[name]);
      if (type === 'undefined' || type === 'null') {
        target[name] = value;
      }

    }, this);

    return target;

  },

  match: function (obj, test) {

    var isMatch = true;

    this.walk(obj, test, function (target, src) {
      isMatch = (target === src);
    });

    return isMatch;

  },

  pick: function(obj, keys) {

    var picked = {};
    keys = this.typeOf(keys) === 'array' ? keys : Object.keys(keys);

    this.each(keys, function (key) {
      picked[key] = obj && obj[key];
    });

    return picked;

  }

};

}, true);

provide('lilobj/arr', function (require, module, exports) {

/*jshint curly:true, eqeqeq:true, immed:true, latedef:true,
  newcap:true, noarg:true, sub:true, undef:true, boss:true,
  strict:false, eqnull:true, browser:true, node:true,
  proto:true */

var _ = require('lil_');

function Arr() {

  var arr = [];
  arr.push.apply(arr, arguments);
  arr.__proto__ = Arr.prototype;

  return arr;

}

Arr.prototype = [];

Arr.prototype.isA = function (prototype) {

  function D() {}
  D.prototype = prototype;
  return this instanceof D;

};

Arr.prototype.extend = function (props) {

    Arr.prototype = this;
    var child = new Arr();

    _.each(props, function (name) {
      child[name] = props[name];
    });

    return child;
};

Arr.prototype.create = function () {

    Arr.prototype = this;
    var child = new Arr();

    if (child.construct !== undefined) {
      child.construct.apply(child, arguments);
    }

    return child;
};

module.exports = new Arr();

}, true);
provide('lilobj/obj', function (require, module, exports) {

/*jshint curly:true, eqeqeq:true, immed:true, latedef:true,
  newcap:true, noarg:true, sub:true, undef:true, boss:true,
  strict:false, eqnull:true, browser:true, node:true */

var _ = require('lil_');

module.exports = {

  isA: function (prototype) {

    function D() {}
    D.prototype = prototype;
    return this instanceof D;

  },

  extend: function (props) {

    var result = Object.create(this);

    _.each(props, function (name, value) {
      result[name] = value;
    });

    return result;

  },

  create: function () {

    var object = Object.create(this);

    if (object.construct !== undefined) {
      object.construct.apply(object, arguments);
    }

    return object;

  }

};

}, true);
provide('lilobj', function (require, module, exports) {

/*jshint curly:true, eqeqeq:true, immed:true, latedef:true,
  newcap:true, noarg:true, sub:true, undef:true, boss:true,
  strict:false, eqnull:true, browser:true, node:true */

var obj = require('./lilobj/obj');
var arr = require('./lilobj/arr');

module.exports = {
  obj: obj,
  arr: arr
};

}, true);


text:
#include "glheader.h"
#include "api_noop.h"
#include "api_validate.h"
#include "api_arrayelt.h"
#include "context.h"
#include "light.h"
#include "macros.h"
#include "dlist.h"
#include "eval.h"
#include "main/dispatch.h"

/**
 * \file
 * Just update the ctx->Current vertex attributes.
 * These functions are used when outside glBegin/glEnd or outside display
 * lists.
 */

#if FEATURE_beginend

static void GLAPIENTRY _mesa_noop_EdgeFlag( GLboolean b )
{
   GET_CURRENT_CONTEXT(ctx);
   ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] = (GLfloat)b;
}

static void GLAPIENTRY _mesa_noop_Indexf( GLfloat f )
{
   GET_CURRENT_CONTEXT(ctx);
   ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0] = f;
}

static void GLAPIENTRY _mesa_noop_Indexfv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0] = *v;
}

static void GLAPIENTRY _mesa_noop_FogCoordfEXT( GLfloat a )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_FOG];
   dest[0] = a;
   dest[1] = 0.0;
   dest[2] = 0.0;
   dest[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_FogCoordfvEXT( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_FOG];
   dest[0] = v[0];
   dest[1] = 0.0;
   dest[2] = 0.0;
   dest[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_Normal3f( GLfloat a, GLfloat b, GLfloat c )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
   dest[0] = a;
   dest[1] = b;
   dest[2] = c;
   dest[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_Normal3fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_NORMAL];
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = v[2];
   dest[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_Color4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
   color[0] = a;
   color[1] = b;
   color[2] = c;
   color[3] = d;
}

static void GLAPIENTRY _mesa_noop_Color4fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
   color[0] = v[0];
   color[1] = v[1];
   color[2] = v[2];
   color[3] = v[3];
}

static void GLAPIENTRY _mesa_noop_Color3f( GLfloat a, GLfloat b, GLfloat c )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
   color[0] = a;
   color[1] = b;
   color[2] = c;
   color[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_Color3fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
   color[0] = v[0];
   color[1] = v[1];
   color[2] = v[2];
   color[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord1fARB( GLenum target, GLfloat a )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = a;
      dest[1] = 0;
      dest[2] = 0;
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord1fvARB( GLenum target, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = v[0];
      dest[1] = 0;
      dest[2] = 0;
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord2fARB( GLenum target, GLfloat a, GLfloat b )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = a;
      dest[1] = b;
      dest[2] = 0;
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord2fvARB( GLenum target, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = v[0];
      dest[1] = v[1];
      dest[2] = 0;
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord3fARB( GLenum target, GLfloat a, GLfloat b, GLfloat c)
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = a;
      dest[1] = b;
      dest[2] = c;
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord3fvARB( GLenum target, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = v[0];
      dest[1] = v[1];
      dest[2] = v[2];
      dest[3] = 1;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord4fARB( GLenum target, GLfloat a, GLfloat b,
			      GLfloat c, GLfloat d )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = a;
      dest[1] = b;
      dest[2] = c;
      dest[3] = d;
   }
}

static void GLAPIENTRY _mesa_noop_MultiTexCoord4fvARB( GLenum target, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLuint unit = target - GL_TEXTURE0_ARB;

   /* unit is unsigned -- cannot be less than zero.
    */
   if (unit < MAX_TEXTURE_COORD_UNITS)
   {
      GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit];
      dest[0] = v[0];
      dest[1] = v[1];
      dest[2] = v[2];
      dest[3] = v[3];
   }
}

static void GLAPIENTRY _mesa_noop_SecondaryColor3fEXT( GLfloat a, GLfloat b, GLfloat c )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
   color[0] = a;
   color[1] = b;
   color[2] = c;
   color[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_SecondaryColor3fvEXT( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *color = ctx->Current.Attrib[VERT_ATTRIB_COLOR1];
   color[0] = v[0];
   color[1] = v[1];
   color[2] = v[2];
   color[3] = 1.0;
}

static void GLAPIENTRY _mesa_noop_TexCoord1f( GLfloat a )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = a;
   dest[1] = 0;
   dest[2] = 0;
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord1fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = v[0];
   dest[1] = 0;
   dest[2] = 0;
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord2f( GLfloat a, GLfloat b )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = a;
   dest[1] = b;
   dest[2] = 0;
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord2fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = 0;
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord3f( GLfloat a, GLfloat b, GLfloat c )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = a;
   dest[1] = b;
   dest[2] = c;
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord3fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = v[2];
   dest[3] = 1;
}

static void GLAPIENTRY _mesa_noop_TexCoord4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = a;
   dest[1] = b;
   dest[2] = c;
   dest[3] = d;
}

static void GLAPIENTRY _mesa_noop_TexCoord4fv( const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat *dest = ctx->Current.Attrib[VERT_ATTRIB_TEX0];
   dest[0] = v[0];
   dest[1] = v[1];
   dest[2] = v[2];
   dest[3] = v[3];
}

/**
 * GL_NV_vertex_program attributes.
 * Note that these attributes alias the conventional vertex attributes.
 */

static void GLAPIENTRY _mesa_noop_VertexAttrib1fNV( GLuint index, GLfloat x )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], x, 0, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib1fvNV( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], 0, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fvNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib2fvNV( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fvNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib3fNV( GLuint index, GLfloat x,
                                  GLfloat y, GLfloat z )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib3fvNV( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fvNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib4fNV( GLuint index, GLfloat x,
                                  GLfloat y, GLfloat z, GLfloat w )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], x, y, z, w);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fNV(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_NV_VERTEX_PROGRAM_INPUTS) {
      ASSIGN_4V(ctx->Current.Attrib[index], v[0], v[1], v[2], v[3]);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fvNV(index)" );
}

/**
 * GL_ARB_vertex_program attributes.
 * Note that these attributes DO NOT alias the conventional vertex attributes.
 */

static void GLAPIENTRY _mesa_noop_VertexAttrib1fARB( GLuint index, GLfloat x )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, 0, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib1fvARB( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], 0, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib1fvARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib2fvARB( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], 0, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib2fvARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib3fARB( GLuint index, GLfloat x,
                                  GLfloat y, GLfloat z )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib3fvARB( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], 1);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib3fvARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib4fARB( GLuint index, GLfloat x,
                                  GLfloat y, GLfloat z, GLfloat w )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], x, y, z, w);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fARB(index)" );
}

static void GLAPIENTRY _mesa_noop_VertexAttrib4fvARB( GLuint index, const GLfloat *v )
{
   GET_CURRENT_CONTEXT(ctx);
   if (index < MAX_VERTEX_GENERIC_ATTRIBS) {
      ASSIGN_4V(ctx->Current.Attrib[VERT_ATTRIB_GENERIC0 + index], v[0], v[1], v[2], v[3]);
   }
   else
      _mesa_error( ctx, GL_INVALID_VALUE, "glVertexAttrib4fvARB(index)" );
}

/**
 * Called by glMaterial*()
 */
void GLAPIENTRY
_mesa_noop_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
{
   GET_CURRENT_CONTEXT(ctx);
   GLint i, nr;
   struct gl_material *mat = &ctx->Light.Material;
   GLuint bitmask = _mesa_material_bitmask( ctx, face, pname, ~0,
                                            "_mesa_noop_Materialfv" );

   if (ctx->Light.ColorMaterialEnabled)
      bitmask &= ~ctx->Light.ColorMaterialBitmask;

   if (bitmask == 0)
      return;

   switch (pname) {
   case GL_SHININESS: nr = 1; break;
   case GL_COLOR_INDEXES: nr = 3; break;
   default: nr = 4 ; break;
   }

   for (i = 0 ; i < MAT_ATTRIB_MAX ; i++)
      if (bitmask & (1<<i))
	 COPY_SZ_4V( mat->Attrib[i], nr, params );

   _mesa_update_material( ctx, bitmask );
}

/**
 * These really are noops outside begin/end:
 */
static void GLAPIENTRY _mesa_noop_Vertex2fv( const GLfloat *v )
{
   (void) v;
}

static void GLAPIENTRY _mesa_noop_Vertex3fv( const GLfloat *v )
{
   (void) v;
}

static void GLAPIENTRY _mesa_noop_Vertex4fv( const GLfloat *v )
{
   (void) v;
}

static void GLAPIENTRY _mesa_noop_Vertex2f( GLfloat a, GLfloat b )
{
   (void) a; (void) b;
}

static void GLAPIENTRY _mesa_noop_Vertex3f( GLfloat a, GLfloat b, GLfloat c )
{
   (void) a; (void) b; (void) c;
}

static void GLAPIENTRY _mesa_noop_Vertex4f( GLfloat a, GLfloat b, GLfloat c, GLfloat d )
{
   (void) a; (void) b; (void) c; (void) d;
}

#if FEATURE_evaluators
/* Similarly, these have no effect outside begin/end:
 */
static void GLAPIENTRY _mesa_noop_EvalCoord1f( GLfloat a )
{
   (void) a;
}

static void GLAPIENTRY _mesa_noop_EvalCoord1fv( const GLfloat *v )
{
   (void) v;
}

static void GLAPIENTRY _mesa_noop_EvalCoord2f( GLfloat a, GLfloat b )
{
   (void) a; (void) b;
}

static void GLAPIENTRY _mesa_noop_EvalCoord2fv( const GLfloat *v )
{
   (void) v;
}

static void GLAPIENTRY _mesa_noop_EvalPoint1( GLint a )
{
   (void) a;
}

static void GLAPIENTRY _mesa_noop_EvalPoint2( GLint a, GLint b )
{
   (void) a; (void) b;
}
#endif /* FEATURE_evaluators */

/* Begin -- call into driver, should result in the vtxfmt being
 * swapped out:
 */
static void GLAPIENTRY _mesa_noop_Begin( GLenum mode )
{
   (void) mode;
}

/* End -- just raise an error
 */
static void GLAPIENTRY _mesa_noop_End( void )
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd(no glBegin)" );
}

/**
 * Execute a glRectf() function.  This is not suitable for GL_COMPILE
 * modes (as the test for outside begin/end is not compiled),
 * but may be useful for drivers in circumstances which exclude
 * display list interactions.
 *
 * (None of the functions in this file are suitable for GL_COMPILE
 * modes).
 */
void GLAPIENTRY
_mesa_noop_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
{
   {
      GET_CURRENT_CONTEXT(ctx);
      ASSERT_OUTSIDE_BEGIN_END(ctx);
   }

   CALL_Begin(GET_DISPATCH(), (GL_QUADS));
   CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
   CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
   CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
   CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
   CALL_End(GET_DISPATCH(), ());
}

/**
 * Some very basic support for arrays.  Drivers without explicit array
 * support can hook these in, but still need to supply an array-elt
 * implementation.
 */
static void GLAPIENTRY
_mesa_noop_DrawArrays(GLenum mode, GLint start, GLsizei count)
{
   GET_CURRENT_CONTEXT(ctx);
   GLint i;

   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
      return;

   CALL_Begin(GET_DISPATCH(), (mode));
   for (i = 0; i < count; i++)
       CALL_ArrayElement(GET_DISPATCH(), (start + i));
   CALL_End(GET_DISPATCH(), ());
}

static void GLAPIENTRY
_mesa_noop_DrawElements(GLenum mode, GLsizei count, GLenum type,
                        const GLvoid *indices)
{
   GET_CURRENT_CONTEXT(ctx);
   GLint i;

   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
      return;

   CALL_Begin(GET_DISPATCH(), (mode));

   switch (type) {
   case GL_UNSIGNED_BYTE:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
      break;
   case GL_UNSIGNED_SHORT:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
      break;
   case GL_UNSIGNED_INT:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
      break;
   default:
      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
      break;
   }

   CALL_End(GET_DISPATCH(), ());
}

static void GLAPIENTRY
_mesa_noop_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
				  const GLvoid *indices, GLint basevertex)
{
   GET_CURRENT_CONTEXT(ctx);
   GLint i;

   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices,
				     basevertex ))
      return;

   CALL_Begin(GET_DISPATCH(), (mode));

   switch (type) {
   case GL_UNSIGNED_BYTE:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] +
					      basevertex));
      break;
   case GL_UNSIGNED_SHORT:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] +
					      basevertex ));
      break;
   case GL_UNSIGNED_INT:
      for (i = 0 ; i < count ; i++)
	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] +
					      basevertex ));
      break;
   default:
      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElementsBaseVertex(type)" );
      break;
   }

   CALL_End(GET_DISPATCH(), ());
}

static void GLAPIENTRY
_mesa_noop_DrawRangeElements(GLenum mode,
                             GLuint start, GLuint end,
                             GLsizei count, GLenum type,
                             const GLvoid *indices)
{
   GET_CURRENT_CONTEXT(ctx);

   if (_mesa_validate_DrawRangeElements( ctx, mode,
					 start, end,
					 count, type, indices, 0 ))
       CALL_DrawElements(GET_DISPATCH(), (mode, count, type, indices));
}

/* GL_EXT_multi_draw_arrays */
void GLAPIENTRY
_mesa_noop_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type,
			     const GLvoid **indices, GLsizei primcount)
{
   GLsizei i;

   for (i = 0; i < primcount; i++) {
      if (count[i] > 0) {
	 CALL_DrawElements(GET_DISPATCH(), (mode, count[i], type, indices[i]));
      }
   }
}

static void GLAPIENTRY
_mesa_noop_DrawRangeElementsBaseVertex(GLenum mode,
				       GLuint start, GLuint end,
				       GLsizei count, GLenum type,
				       const GLvoid *indices, GLint basevertex)
{
   GET_CURRENT_CONTEXT(ctx);

   if (_mesa_validate_DrawRangeElements( ctx, mode,
					 start, end,
					 count, type, indices, basevertex ))
      CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count, type, indices,
						   basevertex));
}

/* GL_EXT_multi_draw_arrays */
void GLAPIENTRY
_mesa_noop_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count,
				       GLenum type,
				       const GLvoid **indices,
				       GLsizei primcount,
				       const GLint *basevertex)
{
   GLsizei i;

   for (i = 0; i < primcount; i++) {
      if (count[i] > 0) {
	 CALL_DrawElementsBaseVertex(GET_DISPATCH(), (mode, count[i], type,
						      indices[i],
						      basevertex[i]));
      }
   }
}

/*
 * Eval Mesh
 */

/**
 * KW:
 * If are compiling, we don't know whether eval will produce a
 * vertex when it is run in the future.  If this is pure immediate
 * mode, eval is a noop if neither vertex map is enabled.
 *
 * Thus we need to have a check in the display list code or elsewhere
 * for eval(1,2) vertices in the case where map(1,2)_vertex is
 * disabled, and to purge those vertices from the vb.
 */
void GLAPIENTRY
_mesa_noop_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
{
   GET_CURRENT_CONTEXT(ctx);
   GLint i;
   GLfloat u, du;
   GLenum prim;

   switch (mode) {
   case GL_POINT:
      prim = GL_POINTS;
      break;
   case GL_LINE:
      prim = GL_LINE_STRIP;
      break;
   default:
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
      return;
   }

   /* No effect if vertex maps disabled.
    */
   if (!ctx->Eval.Map1Vertex4 &&
       !ctx->Eval.Map1Vertex3 &&
       !(ctx->VertexProgram._Enabled && ctx->Eval.Map1Attrib[VERT_ATTRIB_POS]))
      return;

   du = ctx->Eval.MapGrid1du;
   u = ctx->Eval.MapGrid1u1 + i1 * du;

   CALL_Begin(GET_DISPATCH(), (prim));
   for (i=i1;i<=i2;i++,u+=du) {
      CALL_EvalCoord1f(GET_DISPATCH(), (u));
   }
   CALL_End(GET_DISPATCH(), ());
}

void GLAPIENTRY
_mesa_noop_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
{
   GET_CURRENT_CONTEXT(ctx);
   GLfloat u, du, v, dv, v1, u1;
   GLint i, j;

   switch (mode) {
   case GL_POINT:
   case GL_LINE:
   case GL_FILL:
      break;
   default:
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
      return;
   }

   /* No effect if vertex maps disabled.
    */
   if (!ctx->Eval.Map2Vertex4 &&
       !ctx->Eval.Map2Vertex3 &&
       !(ctx->VertexProgram._Enabled && ctx->Eval.Map2Attrib[VERT_ATTRIB_POS]))
      return;

   du = ctx->Eval.MapGrid2du;
   dv = ctx->Eval.MapGrid2dv;
   v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
   u1 = ctx->Eval.MapGrid2u1 + i1 * du;

   switch (mode) {
   case GL_POINT:
      CALL_Begin(GET_DISPATCH(), (GL_POINTS));
      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
	    CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
	 }
      }
      CALL_End(GET_DISPATCH(), ());
      break;
   case GL_LINE:
      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
	 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
	    CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
	 }
	 CALL_End(GET_DISPATCH(), ());
      }
      for (u=u1,i=i1;i<=i2;i++,u+=du) {
	 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
	 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
	    CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
	 }
	 CALL_End(GET_DISPATCH(), ());
      }
      break;
   case GL_FILL:
      for (v=v1,j=j1;j<j2;j++,v+=dv) {
	 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP));
	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
	    CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
	    CALL_EvalCoord2f(GET_DISPATCH(), (u, v+dv));
	 }
	 CALL_End(GET_DISPATCH(), ());
      }
      break;
   default:
      _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
      return;
   }
}

/**
 * Build a vertexformat of functions to use outside begin/end pairs.
 *
 * TODO -- build a whole dispatch table for this purpose, and likewise
 * for inside begin/end.
 */
void
_mesa_noop_vtxfmt_init( GLvertexformat *vfmt )
{
   _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);

   vfmt->Begin = _mesa_noop_Begin;

   _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);

   vfmt->Color3f = _mesa_noop_Color3f;
   vfmt->Color3fv = _mesa_noop_Color3fv;
   vfmt->Color4f = _mesa_noop_Color4f;
   vfmt->Color4fv = _mesa_noop_Color4fv;
   vfmt->EdgeFlag = _mesa_noop_EdgeFlag;
   vfmt->End = _mesa_noop_End;

   _MESA_INIT_EVAL_VTXFMT(vfmt, _mesa_noop_);

   vfmt->FogCoordfEXT = _mesa_noop_FogCoordfEXT;
   vfmt->FogCoordfvEXT = _mesa_noop_FogCoordfvEXT;
   vfmt->Indexf = _mesa_noop_Indexf;
   vfmt->Indexfv = _mesa_noop_Indexfv;
   vfmt->Materialfv = _mesa_noop_Materialfv;
   vfmt->MultiTexCoord1fARB = _mesa_noop_MultiTexCoord1fARB;
   vfmt->MultiTexCoord1fvARB = _mesa_noop_MultiTexCoord1fvARB;
   vfmt->MultiTexCoord2fARB = _mesa_noop_MultiTexCoord2fARB;
   vfmt->MultiTexCoord2fvARB = _mesa_noop_MultiTexCoord2fvARB;
   vfmt->MultiTexCoord3fARB = _mesa_noop_MultiTexCoord3fARB;
   vfmt->MultiTexCoord3fvARB = _mesa_noop_MultiTexCoord3fvARB;
   vfmt->MultiTexCoord4fARB = _mesa_noop_MultiTexCoord4fARB;
   vfmt->MultiTexCoord4fvARB = _mesa_noop_MultiTexCoord4fvARB;
   vfmt->Normal3f = _mesa_noop_Normal3f;
   vfmt->Normal3fv = _mesa_noop_Normal3fv;
   vfmt->SecondaryColor3fEXT = _mesa_noop_SecondaryColor3fEXT;
   vfmt->SecondaryColor3fvEXT = _mesa_noop_SecondaryColor3fvEXT;
   vfmt->TexCoord1f = _mesa_noop_TexCoord1f;
   vfmt->TexCoord1fv = _mesa_noop_TexCoord1fv;
   vfmt->TexCoord2f = _mesa_noop_TexCoord2f;
   vfmt->TexCoord2fv = _mesa_noop_TexCoord2fv;
   vfmt->TexCoord3f = _mesa_noop_TexCoord3f;
   vfmt->TexCoord3fv = _mesa_noop_TexCoord3fv;
   vfmt->TexCoord4f = _mesa_noop_TexCoord4f;
   vfmt->TexCoord4fv = _mesa_noop_TexCoord4fv;
   vfmt->Vertex2f = _mesa_noop_Vertex2f;
   vfmt->Vertex2fv = _mesa_noop_Vertex2fv;
   vfmt->Vertex3f = _mesa_noop_Vertex3f;
   vfmt->Vertex3fv = _mesa_noop_Vertex3fv;
   vfmt->Vertex4f = _mesa_noop_Vertex4f;
   vfmt->Vertex4fv = _mesa_noop_Vertex4fv;
   vfmt->VertexAttrib1fNV = _mesa_noop_VertexAttrib1fNV;
   vfmt->VertexAttrib1fvNV = _mesa_noop_VertexAttrib1fvNV;
   vfmt->VertexAttrib2fNV = _mesa_noop_VertexAttrib2fNV;
   vfmt->VertexAttrib2fvNV = _mesa_noop_VertexAttrib2fvNV;
   vfmt->VertexAttrib3fNV = _mesa_noop_VertexAttrib3fNV;
   vfmt->VertexAttrib3fvNV = _mesa_noop_VertexAttrib3fvNV;
   vfmt->VertexAttrib4fNV = _mesa_noop_VertexAttrib4fNV;
   vfmt->VertexAttrib4fvNV = _mesa_noop_VertexAttrib4fvNV;
   vfmt->VertexAttrib1fARB = _mesa_noop_VertexAttrib1fARB;
   vfmt->VertexAttrib1fvARB = _mesa_noop_VertexAttrib1fvARB;
   vfmt->VertexAttrib2fARB = _mesa_noop_VertexAttrib2fARB;
   vfmt->VertexAttrib2fvARB = _mesa_noop_VertexAttrib2fvARB;
   vfmt->VertexAttrib3fARB = _mesa_noop_VertexAttrib3fARB;
   vfmt->VertexAttrib3fvARB = _mesa_noop_VertexAttrib3fvARB;
   vfmt->VertexAttrib4fARB = _mesa_noop_VertexAttrib4fARB;
   vfmt->VertexAttrib4fvARB = _mesa_noop_VertexAttrib4fvARB;

   vfmt->Rectf = _mesa_noop_Rectf;

   vfmt->DrawArrays = _mesa_noop_DrawArrays;
   vfmt->DrawElements = _mesa_noop_DrawElements;
   vfmt->DrawRangeElements = _mesa_noop_DrawRangeElements;
   vfmt->MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
   vfmt->DrawElementsBaseVertex = _mesa_noop_DrawElementsBaseVertex;
   vfmt->DrawRangeElementsBaseVertex = _mesa_noop_DrawRangeElementsBaseVertex;
   vfmt->MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
}

#endif /* FEATURE_beginend */


text:
<?xml version="1.0" encoding="utf-8"?>
<doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
  <entity name="MdlLanguagelabStudentEval" table="mdl_languagelab_student_eval">
    <indexes>
      <index name="mdl_langstudeval_lan_ix" columns="languagelab"/>
    </indexes>
    <id name="id" type="bigint" column="id">
      <generator strategy="IDENTITY"/>
    </id>
    <field name="languagelab" type="bigint" column="languagelab" nullable="false"/>
    <field name="userid" type="bigint" column="userid" nullable="false"/>
    <field name="correctionnotes" type="text" column="correctionnotes" nullable="true"/>
    <field name="grade" type="bigint" column="grade" nullable="true"/>
    <field name="teacher" type="bigint" column="teacher" nullable="true"/>
    <field name="timemarked" type="bigint" column="timemarked" nullable="true"/>
    <field name="timecreated" type="bigint" column="timecreated" nullable="true"/>
    <field name="timemodified" type="bigint" column="timemodified" nullable="false"/>
  </entity>
</doctrine-mapping>


text:
package cz.kuzna.android.dbvarna.annotation;

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

/**
 * @author Radek Kuznik
 */
@Target({ ElementType.PARAMETER, ElementType.METHOD, ElementType.CONSTRUCTOR })
@Retention(RetentionPolicy.CLASS)
public @interface Getter {

    String value() default "";
}


text:
@extends('backend::layout')
@section('page_header', trans("backend.profile.profile"))
@section('page_description', trans("backend.profile.edit"))

@section('content')

  {!! Form::model($admin, ['method' => 'PATCH', 'route' => ['zxadmin.update']]) !!}

        {!! Form::label("email", trans("backend.profile.email"), ['class' => 'label-text']) !!}
        {!! Form::text("email", null, ['class' => 'form-control']) !!}

        {!! Form::label("name", trans("backend.profile.name"), ['class' => 'label-text']) !!}
        {!! Form::text("name", null, ['class' => 'form-control']) !!}

        {!! Form::label("password", trans("backend.profile.password"), ['class' => 'label-text']) !!}
        <input class="form-control" name="password" type="password" id="password">

        {!! Form::label("password_confirmation", trans("backend.profile.password_confirmation"), ['class' => 'label-text']) !!}
        <input type="password" id="password_confirmation" class="form-control" name="password_confirmation">

has('my_password') ? 'has-error' : ''}}">
        {!! Form::label("my_password", trans("backend.profile.current_password"), ['class' => 'label-text text-red']) !!}
          <input class="form-control" name="my_password" type="password" id="my_password">
          {!! $errors->first('my_password', '
:message
') !!}

      @if ($errors->has('demo_update_admin_profile'))

          {!! $errors->first('demo_update_admin_profile') !!}

      @endif

        <button type="submit" class="btn btn-primary pull-right"> {!! trans('backend.profile.edit') !!}</button>

  {!! Form::close() !!}

@endsection


text:
import {
    InnerBlocks,
    InspectorControls,
    __experimentalBlockVariationPicker,
} from "@wordpress/block-editor"
import { useSelect, useDispatch } from "@wordpress/data"
import {
    SVG,
    Path,
    PanelBody,
    PanelRow,
    ToggleControl,
} from "@wordpress/components"
import { createBlock } from "@wordpress/blocks"
import { get, map } from "lodash"

const blockStyle = {
    border: "1px dashed lightgrey",
    padding: "0 1rem",
}

const variationsTemplates = [
    {
        name: "left-column-media",
        title: "Left column, with image",
        icon: (
            <SVG
                width="48"
                height="48"
                viewBox="0 0 48 48"
                xmlns="http://www.w3.org/2000/svg"
            >
                <Path
                    fillRule="evenodd"
                    clipRule="evenodd"
                    d="M39 12C40.1046 12 41 12.8954 41 14V34C41 35.1046 40.1046 36 39 36H9C7.89543 36 7 35.1046 7 34V14C7 12.8954 7.89543 12 9 12H39ZM39 34V14H20V34H39ZM18 34H9V14H18V34Z"
                />
            </SVG>
        ),
        innerBlocks: [
            ["core/heading", { level: 3 }],
            [
                "core/columns",
                { className: "is-style-merge-left" },
                [
                    ["core/column", { width: 25 }, [["core/image"]]],
                    [
                        "core/column",
                        { width: 75 },
                        [
                            [
                                "core/paragraph",
                                { placeholder: "Enter side content..." },
                            ],
                        ],
                    ],
                ],
            ],
        ],
    },
    {
        name: "full-width-sticky-right",
        title: "Full width, with chart",
        icon: (
            <SVG
                width="48"
                height="48"
                viewBox="0 0 48 48"
                xmlns="http://www.w3.org/2000/svg"
            >
                <Path
                    fillRule="evenodd"
                    clipRule="evenodd"
                    d="M39 12C40.1046 12 41 12.8954 41 14V34C41 35.1046 40.1046 36 39 36H9C7.89543 36 7 35.1046 7 34V14C7 12.8954 7.89543 12 9 12H39ZM39 34V14H25V34H39ZM23 34H9V14H23V34Z"
                />
            </SVG>
        ),
        innerBlocks: [
            ["core/heading", { level: 3 }],
            [
                "core/columns",
                { className: "is-style-sticky-right" },
                [
                    ["core/column", {}, [["core/paragraph"]]],
                    ["core/column", {}, [["core/html"]]],
                ],
            ],
        ],
    },
]

const AdditionalInformation = {
    title: "Additional information",
    icon: "info",
    category: "formatting",
    supports: {
        html: false,
    },
    attributes: {
        defaultOpen: {
            type: "boolean",
        },
    },
    // Use of variations (previously template options) is still experimental and now undocumented.
    // Some useful references in the meantime:
    // - core columns blocks (where most of the following code comes from):
    //   https://github.com/WordPress/gutenberg/blob/master/packages/block-library/src/columns/edit.js
    // - https://plugins.trac.wordpress.org/changeset/2243801/nhsblocks (00-dashboard/index.js)
    edit: ({ clientId, name, attributes: { defaultOpen }, setAttributes }) => {
        const { blockType, defaultVariation, hasInnerBlocks, variations } =
            useSelect(
                (select) => {
                    const {
                        getBlockVariations,
                        getBlockType,
                        getDefaultBlockVariation,
                    } = select("core/blocks")

                    return {
                        blockType: getBlockType(name),
                        defaultVariation: getDefaultBlockVariation(
                            name,
                            "block"
                        ),
                        hasInnerBlocks:
                            select("core/block-editor").getBlocks(clientId)
                                .length > 0,
                        variations: getBlockVariations(name, "block"),
                    }
                },
                [clientId, name]
            )

        const { replaceInnerBlocks } = useDispatch("core/block-editor")

        const createBlocksFromInnerBlocksTemplate = (innerBlocksTemplate) => {
            return map(
                innerBlocksTemplate,
                ([name, attributes, innerBlocks = []]) =>
                    createBlock(
                        name,
                        attributes,
                        createBlocksFromInnerBlocksTemplate(innerBlocks)
                    )
            )
        }

        return (
            <>
                <InspectorControls>
                    <PanelBody title="Default visibility" initialOpen={true}>
                        <PanelRow>
                            <ToggleControl
                                label={`${
                                    defaultOpen ? "Open" : "Closed"
                                } by default`}
                                help="Defines whether the block is open (expanded) or closed (collapsed) by default. The reader will still be able to toggle the block's visibility independently of that setting."
                                checked={!!defaultOpen}
                                onChange={(isChecked) => {
                                    setAttributes({ defaultOpen: isChecked })
                                }}
                            />
                        </PanelRow>
                    </PanelBody>
                </InspectorControls>
                <div style={blockStyle}>
                    {hasInnerBlocks ? (
                        <InnerBlocks />
                    ) : (
                        <__experimentalBlockVariationPicker
                            icon={get(blockType, ["icon", "src"])}
                            label={get(blockType, ["title"])}
                            variations={variationsTemplates}
                            onSelect={(nextVariation = defaultVariation) => {
                                if (nextVariation.attributes) {
                                    setAttributes(nextVariation.attributes)
                                }
                                if (nextVariation.innerBlocks) {
                                    replaceInnerBlocks(
                                        clientId,
                                        createBlocksFromInnerBlocksTemplate(
                                            nextVariation.innerBlocks
                                        )
                                    )
                                }
                            }}
                            allowSkip={false}
                        />
                    )}
                </div>
            </>
        )
    },

    save: (props) => <InnerBlocks.Content />,
}

export default AdditionalInformation


text:
//
//  JPSpecialInit.h
//  SwiftDemo
//
//  Created by KouArlen on 16/2/25.
//  Copyright © 2016年 Arlen. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

/**
 handle the Init of some Special Class
 https://github.com/bang590/JSPatch/issues/248

 */

@interface JPSpecialInit : NSObject

+ (NSCalendar *)calendarWithCalendarIdentifier:(NSString *)iden;
+ (UIWebView *)newWebView;
@end


text:
using AFrame.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AFrame.Desktop.Controls.Win
{
    public class WinGroup : WinControl
    {
        public WinGroup()
        {
            this.SearchProperties.Add(new SearchProperty(WinControl.PropertyNames.ControlType, "Group"));
        }

        public WinGroup(DesktopContext context)
            : base(context)
        {
            this.SearchProperties.Add(new SearchProperty(WinControl.PropertyNames.ControlType, "Group"));
        }

        public new class PropertyNames : WinControl.PropertyNames
        {
        }
    }
}


text:
using UnityEngine;
using System.Collections;
using Lockstep;
using System.Collections.Generic;
namespace Lockstep
{
    public class DefaultSaver : EnvironmentSaver
    {
        [SerializeField]
        private EnvironmentBodyInfo[] _environmentBodies;
        public EnvironmentBodyInfo[] EnvironmentBodies {get {return _environmentBodies;}}
        [SerializeField]
        private EnvironmentObject[] _environmentObjects;
        public EnvironmentObject[] EnvironmentObjects {get {return _environmentObjects;}}

        protected override void OnSave () {
            SaveBodies ();
            SaveObjects ();
        }

        protected override void OnApply () {
            foreach (EnvironmentObject obj in EnvironmentObjects) {
                obj.Initialize();
            }
        }

        protected override void OnLateApply()
        {
            foreach (EnvironmentBodyInfo info in EnvironmentBodies) {
                info.Body.Initialize(info.Position,info.Rotation);
            }

            foreach (EnvironmentObject obj in EnvironmentObjects) {
                obj.LateInitialize();
            }
        }

        void SaveBodies () {
            LSBody[] allBodies = GameObject.FindObjectsOfType<LSBody> ();
            FastList<EnvironmentBodyInfo> bodiesBuffer = new FastList<EnvironmentBodyInfo>();
            foreach (LSBody body in allBodies) {
                if (IsAgent(body)) continue;
                Vector2dHeight pos = new Vector2dHeight(body.transform.position);
                Vector2d rot = Vector2d.CreateRotation(body.transform.eulerAngles.y * Mathf.Deg2Rad);
                EnvironmentBodyInfo bodyInfo = new EnvironmentBodyInfo(
                    body,
                    pos,
                    rot
                );
                bodiesBuffer.Add(bodyInfo);
            }

            _environmentBodies = bodiesBuffer.ToArray();
        }
        void SaveObjects () {
            EnvironmentObject[] allObjects = GameObject.FindObjectsOfType<EnvironmentObject> ();
            FastList<EnvironmentObject> objectBuffer = new FastList<EnvironmentObject>();

            foreach (EnvironmentObject obj in allObjects) {
                if (IsAgent(obj)) continue;
                objectBuffer.Add(obj);
            }
            _environmentObjects = objectBuffer.ToArray();
        }
        static bool IsAgent (object obj) {
            MonoBehaviour mb = obj as MonoBehaviour;
            if (mb.IsNull()) return false;
            return mb.GetComponent<LSAgent>().IsNotNull();
        }

    }
}


text:
<?php

namespace Doctrine\MongoDB\Tests\Aggregation\Stage;

use Doctrine\MongoDB\Aggregation\Stage\Sample;
use Doctrine\MongoDB\Tests\Aggregation\AggregationTestCase;
use Doctrine\MongoDB\Tests\TestCase;

class SampleTest extends TestCase
{
    use AggregationTestCase;

    public function testSampleStage()
    {
        $sampleStage = new Sample($this->getTestAggregationBuilder(), 10);

        $this->assertSame(['$sample' => ['size' => 10]], $sampleStage->getExpression());
    }

    public function testSampleFromBuilder()
    {
        $builder = $this->getTestAggregationBuilder();
        $builder->sample(10);

        $this->assertSame([['$sample' => ['size' => 10]]], $builder->getPipeline());
    }
}


text:
<!DOCTYPE html>

 Hello,
My name is

Zambino
the weird.
(QED)
and don't you forget it.

Where

in

the world

are my marbles?

<button onclick="(function(){var a=document.createElement('script');a.type='text/javascript';a.src='https://accdc.github.io/visual-aria/visual-aria/roles.js';document.head.appendChild(a)})()">
Load Visual ARIA
</button>
<button onclick="document.getElementById('calcTextStr').innerHTML = getNames(document.getElementById('lblId'));">
Calculate Accessible Name and Description
</button>

<textarea id="calcTextStr" readonly aria-label="Accessible Name and Description Calculation" title="Accessible Name and Description Calculation" style="width: 100%; height: 60px;"></textarea>


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

@import Foundation;

/*!
 *  Error domain for Rich Relevance SDK errors.
 */
OBJC_EXTERN NSString *const kRCHSDKErrorDomain;

/*!
 *  Rich Relevance SDK error codes.
 */
typedef NS_ENUM(NSInteger, RCHSDKErrorCode) {
    /*!
     *  An uknown error occurred.
     */
    RCHSDKErrorCodeUnknown = 0,
    /*!
     *  The SDK was not properly configured prior to executing requests.
     */
    RCHSDKErrorCodeSDKNotConfigured,
    /*!
     *  Invalid arguments were passed to an SDK method such that it could not be executed.
     */
    RCHSDKErrorCodeInvalidArguments,
    /*!
     *  An API response could not be parsed.
     */
    RCHSDKErrorCodeCannotParseResponse,
    /*!
     *  The Rich Relevance API responded with an error.
     */
    RCHSDKErrorCodeAPIError,
    /*!
     *  An HTTP error was encountered.
     */
    RCHSDKErrorCodeHTTPError
};


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE document PUBLIC "-//Gemini Observatory//DTD for Storage of P1 and P2 Documents//EN" "http://ftp.gemini.edu/Support/xml/dtds/SpXML2.dtd">

<document>
  <container kind="program" type="Program" version="2016B-2" subtype="basic" key="298e2411-6551-4551-a17c-005c5e13a827" name="">
    <paramset name="Science Program" kind="dataObj">
      <param name="programMode" value="QUEUE"/>
      <param name="tooType" value="none"/>
      <param name="programStatus" value="PHASE2"/>
      <param name="nextObsId" value="1"/>
      <paramset name="timeAcct"/>
      <param name="awardedTime" value="0.0" units="hours"/>
      <param name="fetched" value="true"/>
      <param name="completed" value="false"/>
      <param name="notifyPi" value="YES"/>
    </paramset>
    <container kind="observation" type="Observation" version="2014A-1" subtype="basic" key="98635570-1426-41d5-bd8a-17136cf2e603" name="">
      <paramset name="Observation" kind="dataObj">
        <param name="title" value="GMOS-N Observation"/>
        <param name="libraryId" value=""/>
        <param name="priority" value="LOW"/>
        <param name="tooOverrideRapid" value="false"/>
        <param name="phase2Status" value="PI_TO_COMPLETE"/>
        <paramset name="schedulingBlock">
          <param name="start" value="1477935000000"/>
          <paramset name="duration">
            <param name="tag" value="unstated"/>
          </paramset>
        </paramset>
        <param name="qaState" value="UNDEFINED"/>
        <param name="overrideQaState" value="false"/>
      </paramset>
      <container kind="obsComp" type="Scheduling" version="2009A-1" subtype="conditions" key="eab019c6-0ef4-4b43-b20d-1a1a35bac53f" name="Observing Conditions">
        <paramset name="Observing Conditions" kind="dataObj">
          <param name="CloudCover" value="ANY"/>
          <param name="ImageQuality" value="ANY"/>
          <param name="SkyBackground" value="ANY"/>
          <param name="WaterVapor" value="ANY"/>
          <param name="ElevationConstraintType" value="NONE"/>
          <param name="ElevationConstraintMin" value="0.0"/>
          <param name="ElevationConstraintMax" value="0.0"/>
          <paramset name="timing-window-list"/>
        </paramset>
      </container>
      <container kind="obsComp" type="Telescope" version="2009B-1" subtype="targetEnv" key="dcd6271c-a0c2-4093-b98d-b2003824b159" name="Targets">
        <paramset name="Targets" kind="dataObj">
          <paramset name="targetEnv">
            <paramset name="base">
              <paramset name="target">
                <param name="name" value="Vesta"/>
                <paramset name="horizons-designation">
                  <param name="num" value="4"/>
                  <param name="tag" value="asteroid-old-style"/>
                </paramset>
                <paramset name="ephemeris">
                  <param name="site" value="GN"/>
                  <paramset name="ephemeris-element">
                    <param name="time" value="1467331200000"/>
                    <paramset name="coordinates">
                      <param name="ra" value="78.66414833333334"/>
                      <param name="dec" value="20.211091944444433"/>
                    </paramset>
                  </paramset>
                  <paramset name="ephemeris-element">
                    <param name="time" value="1477921200000"/>
                    <paramset name="coordinates">
                      <param name="ra" value="124.40285291666669"/>
                      <param name="dec" value="19.050720555555586"/>
                    </paramset>
                  </paramset>
                  <paramset name="ephemeris-element">
                    <param name="time" value="1488313080000"/>
                    <paramset name="coordinates">
                      <param name="ra" value="112.37534291666668"/>
                      <param name="dec" value="26.111878888888896"/>
                    </paramset>
                  </paramset>
                </paramset>
                <param name="tag" value="nonsidereal"/>
              </paramset>
            </paramset>
            <paramset name="guideEnv">
              <param name="primary" value="0"/>
              <paramset name="guideGroup">
                <param name="tag" value="AutoInitialTag"/>
              </paramset>
            </paramset>
          </paramset>
        </paramset>
      </container>
      <container kind="obsComp" type="Instrument" version="2009A-1" subtype="GMOS" key="9a0a060c-98ef-4cd9-bd2d-e98d95c34e1c" name="GMOS-N">
        <paramset name="GMOS-N" kind="dataObj">
          <param name="exposureTime" value="0.0"/>
          <param name="posAngle" value="0"/>
          <param name="coadds" value="1"/>
          <param name="adc" value="NONE"/>
          <param name="ampCount" value="SIX"/>
          <param name="gainChoice" value="LOW"/>
          <param name="ampReadMode" value="SLOW"/>
          <param name="detectorManufacturer" value="E2V"/>
          <param name="disperser" value="MIRROR"/>
          <param name="fpuMode" value="BUILTIN"/>
          <param name="fpu" value="FPU_NONE"/>
          <param name="filter" value="NONE"/>
          <param name="ccdXBinning" value="ONE"/>
          <param name="ccdYBinning" value="ONE"/>
          <param name="issPort" value="SIDE_LOOKING"/>
          <param name="posAngleConstraint" value="FIXED"/>
          <param name="stageMode" value="FOLLOW_XY"/>
          <param name="dtaXOffset" value="ZERO"/>
          <param name="builtinROI" value="FULL_FRAME"/>
          <param name="useNS" value="FALSE"/>
          <param name="mosPreimaging" value="NO"/>
        </paramset>
      </container>
      <container kind="obsQaLog" type="ObsLog" version="2009A-1" subtype="qa" key="3a54bce1-20a5-4a52-8094-79f7cd8259e5" name="Observing Log">
        <paramset name="Observing Log" kind="dataObj">
          <paramset name="obsQaRecord"/>
        </paramset>
      </container>
      <container kind="obsExecLog" type="ObsLog" version="2009A-1" subtype="exec" key="851e0860-9262-4353-af04-1bdebadd8f69" name="Observation Exec Log">
        <paramset name="Observation Exec Log" kind="dataObj">
          <paramset name="obsExecRecord">
            <paramset name="datasets"/>
            <paramset name="events"/>
            <paramset name="configMap"/>
          </paramset>
        </paramset>
      </container>
      <container kind="seqComp" type="Iterator" version="2012A-1" subtype="base" key="68965315-ddf0-4846-b703-6231cb34af78" name="Sequence">
        <paramset name="Sequence" kind="dataObj"/>
        <container kind="seqComp" type="Observer" version="2009A-1" subtype="observe" key="11aaa331-888c-4be0-950b-39c12a0a1f0f" name="Observe">
          <paramset name="Observe" kind="dataObj">
            <param name="repeatCount" value="1"/>
            <param name="class" value="SCIENCE"/>
          </paramset>
        </container>
      </container>
    </container>
  </container>
  <container kind="versions" type="versions" version="1.0">
    <paramset name="node">
      <param name="key" value="298e2411-6551-4551-a17c-005c5e13a827"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="68965315-ddf0-4846-b703-6231cb34af78"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="2"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="9a0a060c-98ef-4cd9-bd2d-e98d95c34e1c"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="2"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="11aaa331-888c-4be0-950b-39c12a0a1f0f"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="851e0860-9262-4353-af04-1bdebadd8f69"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="dcd6271c-a0c2-4093-b98d-b2003824b159"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="10"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="3a54bce1-20a5-4a52-8094-79f7cd8259e5"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="98635570-1426-41d5-bd8a-17136cf2e603"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
    <paramset name="node">
      <param name="key" value="eab019c6-0ef4-4b43-b20d-1a1a35bac53f"/>
      <param name="ada5211d-fc1d-4f8a-ac32-ea9fdded85dc" value="1"/>
    </paramset>
  </container>
</document>


text:
package com.hazelcast.demo;

import com.hazelcast.config.Config;
import com.hazelcast.config.XmlConfigBuilder;
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.HazelcastInstanceNotActiveException;
import com.hazelcast.core.IMap;
import com.hazelcast.core.Member;
import com.hazelcast.core.Partition;
import com.hazelcast.logging.ILogger;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;

/**
 * A simple test of a map.
 */
public final class SimpleMapTest {

    private static final String NAMESPACE = "default";
    private static final long STATS_SECONDS = 10;

    private final HazelcastInstance instance;
    private final ILogger logger;
    private final Stats stats = new Stats();
    private final Random random;

    private final int threadCount;
    private final int entryCount;
    private final int valueSize;
    private final int getPercentage;
    private final int putPercentage;
    private final boolean load;

    static {
        System.setProperty("hazelcast.version.check.enabled", "false");
        System.setProperty("java.net.preferIPv4Stack", "true");
    }

    private SimpleMapTest(final int threadCount, final int entryCount, final int valueSize,
                          final int getPercentage, final int putPercentage, final boolean load) {
        this.threadCount = threadCount;
        this.entryCount = entryCount;
        this.valueSize = valueSize;
        this.getPercentage = getPercentage;
        this.putPercentage = putPercentage;
        this.load = load;
        Config cfg = new XmlConfigBuilder().build();

        instance = Hazelcast.newHazelcastInstance(cfg);
        logger = instance.getLoggingService().getLogger("SimpleMapTest");
        random = new Random();
    }

    /**
     *
     * Expects the Management Center to be running.
     * @param input
     * @throws InterruptedException
     */
    public static void main(String[] input) throws InterruptedException {
        int threadCount = 40;
        int entryCount = 10 * 1000;
        int valueSize = 1000;
        int getPercentage = 40;
        int putPercentage = 40;
        boolean load = false;

        if (input != null && input.length > 0) {
            for (String arg : input) {
                arg = arg.trim();
                if (arg.startsWith("t")) {
                    threadCount = Integer.parseInt(arg.substring(1));
                } else if (arg.startsWith("c")) {
                    entryCount = Integer.parseInt(arg.substring(1));
                } else if (arg.startsWith("v")) {
                    valueSize = Integer.parseInt(arg.substring(1));
                } else if (arg.startsWith("g")) {
                    getPercentage = Integer.parseInt(arg.substring(1));
                } else if (arg.startsWith("p")) {
                    putPercentage = Integer.parseInt(arg.substring(1));
                } else if (arg.startsWith("load")) {
                    load = true;
                }
            }
        } else {
            System.out.println("Help: sh test.sh t200 v130 p10 g85 ");
            System.out.println("means 200 threads, value-size 130 bytes, 10% put, 85% get");
            System.out.println();
        }

        SimpleMapTest test = new SimpleMapTest(threadCount, entryCount, valueSize, getPercentage, putPercentage, load);
        test.start();
    }

    private void start() throws InterruptedException {
        printVariables();
        ExecutorService es = Executors.newFixedThreadPool(threadCount);
        startPrintStats();
        load(es);
        run(es);
    }

    private void run(ExecutorService es) {
        final IMap<String, Object> map = instance.getMap(NAMESPACE);
        for (int i = 0; i < threadCount; i++) {
            es.execute(new Runnable() {
                public void run() {
                    try {
                        while (true) {
                            int key = (int) (random.nextFloat() * entryCount);
                            int operation = ((int) (random.nextFloat() * 100));
                            if (operation < getPercentage) {
                                map.get(String.valueOf(key));
                                stats.gets.incrementAndGet();
                            } else if (operation < getPercentage + putPercentage) {
                                map.put(String.valueOf(key), createValue());
                                stats.puts.incrementAndGet();
                            } else {
                                map.remove(String.valueOf(key));
                                stats.removes.incrementAndGet();
                            }
                        }
                    } catch (HazelcastInstanceNotActiveException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    private Object createValue() {
        return new byte[valueSize];
    }

    private void load(ExecutorService es) throws InterruptedException {
        if (!load) {
            return;
        }

        final IMap<String, Object> map = instance.getMap(NAMESPACE);
        final Member thisMember = instance.getCluster().getLocalMember();
        List<String> lsOwnedEntries = new LinkedList<String>();
        for (int i = 0; i < entryCount; i++) {
            final String key = String.valueOf(i);
            Partition partition = instance.getPartitionService().getPartition(key);
            if (thisMember.equals(partition.getOwner())) {
                lsOwnedEntries.add(key);
            }
        }
        final CountDownLatch latch = new CountDownLatch(lsOwnedEntries.size());
        for (final String ownedKey : lsOwnedEntries) {
            es.execute(new Runnable() {
                public void run() {
                    map.put(ownedKey, createValue());
                    latch.countDown();
                }
            });
        }
        latch.await();
    }

    private void startPrintStats() {
        Thread t = new Thread() {
            {
                setDaemon(true);
                setName("PrintStats." + instance.getName());
            }

            public void run() {
                while (true) {
                    try {
                        Thread.sleep(STATS_SECONDS * 1000);
                        stats.printAndReset();
                    } catch (InterruptedException ignored) {
                        return;
                    }
                }
            }
        };
        t.start();
    }

    /**
     * A basic statistics class
     */
    private class Stats {

        private AtomicLong gets = new AtomicLong();
        private AtomicLong puts = new AtomicLong();
        private AtomicLong removes = new AtomicLong();

        public void printAndReset() {
            long getsNow = gets.getAndSet(0);
            long putsNow = puts.getAndSet(0);
            long removesNow = removes.getAndSet(0);
            long total = getsNow + putsNow + removesNow;

            logger.info("total= " + total + ", gets:" + getsNow
                    + ", puts:" + putsNow + ", removes:" + removesNow);
            logger.info("Operations per Second : " + total / STATS_SECONDS);
        }
    }

    private void printVariables() {
        logger.info("Starting Test with ");
        logger.info("Thread Count: " + threadCount);
        logger.info("Entry Count: " + entryCount);
        logger.info("Value Size: " + valueSize);
        logger.info("Get Percentage: " + getPercentage);
        logger.info("Put Percentage: " + putPercentage);
        logger.info("Remove Percentage: " + (100 - (putPercentage + getPercentage)));
        logger.info("Load: " + load);
    }
}