text:
package java.lang.reflect;

import java.lang.annotation.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import sun.reflect.annotation.AnnotationSupport;

/**
 * Information about method parameters.
 *
 * A {@code Parameter} provides information about method parameters,
 * including its name and modifiers.  It also provides an alternate
 * means of obtaining attributes for the parameter.
 *
 * @since 1.8
 */
public final class Parameter implements AnnotatedElement {

    private final String name;
    private final int modifiers;
    private final Executable executable;
    private final int index;

    /**
     * Package-private constructor for {@code Parameter}.
     *
     * If method parameter data is present in the classfile, then the
     * JVM creates {@code Parameter} objects directly.  If it is
     * absent, however, then {@code Executable} uses this constructor
     * to synthesize them.
     *
     * @param name The name of the parameter.
     * @param modifiers The modifier flags for the parameter.
     * @param executable The executable which defines this parameter.
     * @param index The index of the parameter.
     */
    Parameter(String name,
              int modifiers,
              Executable executable,
              int index) {
        this.name = name;
        this.modifiers = modifiers;
        this.executable = executable;
        this.index = index;
    }

    /**
     * Compares based on the executable and the index.
     *
     * @param obj The object to compare.
     * @return Whether or not this is equal to the argument.
     */
    @Override
    public boolean equals(Object obj) {
        return (obj instanceof Parameter other)
                && other.executable.equals(executable)
                && other.index == index;
    }

    /**
     * Returns a hash code based on the executable's hash code and the
     * index.
     *
     * @return A hash code based on the executable's hash code.
     */
    @Override
    public int hashCode() {
        return executable.hashCode() ^ index;
    }

    /**
     * Returns true if the parameter has a name according to the class
     * file; returns false otherwise. Whether a parameter has a name
     * is determined by the {@literal MethodParameters} attribute of
     * the method which declares the parameter.
     *
     * @return true if and only if the parameter has a name according
     * to the class file.
     */
    public boolean isNamePresent() {
        return executable.hasRealParameterData() && name != null;
    }

    /**
     * Returns a string describing this parameter.  The format is the
     * modifiers for the parameter, if any, in canonical order as
     * recommended by The Java Language
     * Specification, followed by the fully-qualified type of
     * the parameter (excluding the last [] if the parameter is
     * variable arity), followed by "..." if the parameter is variable
     * arity, followed by a space, followed by the name of the
     * parameter.
     *
     * @return A string representation of the parameter and associated
     * information.
     */
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        final Type type = getParameterizedType();
        final String typename = type.getTypeName();

        sb.append(Modifier.toString(getModifiers()));

        if(0 != modifiers)
            sb.append(' ');

        if(isVarArgs())
            sb.append(typename.replaceFirst("\\[\\]$", "..."));
        else
            sb.append(typename);

        sb.append(' ');
        sb.append(getName());

        return sb.toString();
    }

    /**
     * {@return the {@code Executable} declaring this parameter}
     */
    public Executable getDeclaringExecutable() {
        return executable;
    }

    /**
     * {@return the Java language {@linkplain Modifier modifiers} for
     * the parameter represented by this object}
     *
     * @jls 8.4.1 Formal Parameters
     * @see Java
     * programming language and JVM modeling in core reflection
     */
    public int getModifiers() {
        return modifiers;
    }

    /**
     * Returns the name of the parameter.  If the parameter's name is
     * {@linkplain #isNamePresent() present}, then this method returns
     * the name provided by the class file. Otherwise, this method
     * synthesizes a name of the form argN, where N is the index of
     * the parameter in the descriptor of the method which declares
     * the parameter.
     *
     * @return The name of the parameter, either provided by the class
     *         file or synthesized if the class file does not provide
     *         a name.
     */
    public String getName() {
        // Note: empty strings as parameter names are now outlawed.
        // The .isEmpty() is for compatibility with current JVM
        // behavior.  It may be removed at some point.
        if(name == null || name.isEmpty())
            return "arg" + index;
        else
            return name;
    }

    // Package-private accessor to the real name field.
    String getRealName() {
        return name;
    }

    /**
     * Returns a {@code Type} object that identifies the parameterized
     * type for the parameter represented by this {@code Parameter}
     * object.
     *
     * @return a {@code Type} object identifying the parameterized
     * type of the parameter represented by this object
     */
    public Type getParameterizedType() {
        Type tmp = parameterTypeCache;
        if (null == tmp) {
            tmp = executable.getAllGenericParameterTypes()[index];
            parameterTypeCache = tmp;
        }

        return tmp;
    }

    private transient volatile Type parameterTypeCache;

    /**
     * Returns a {@code Class} object that identifies the
     * declared type for the parameter represented by this
     * {@code Parameter} object.
     *
     * @return a {@code Class} object identifying the declared
     * type of the parameter represented by this object
     */
    public Class<?> getType() {
        Class<?> tmp = parameterClassCache;
        if (null == tmp) {
            tmp = executable.getParameterTypes()[index];
            parameterClassCache = tmp;
        }
        return tmp;
    }

    /**
     * Returns an AnnotatedType object that represents the use of a type to
     * specify the type of the formal parameter represented by this Parameter.
     *
     * @return an {@code AnnotatedType} object representing the use of a type
     *         to specify the type of the formal parameter represented by this
     *         Parameter
     */
    public AnnotatedType getAnnotatedType() {
        // no caching for now
        return executable.getAnnotatedParameterTypes()[index];
    }

    private transient volatile Class<?> parameterClassCache;

    /**
     * Returns {@code true} if this parameter is implicitly declared
     * in source code; returns {@code false} otherwise.
     *
     * @return true if and only if this parameter is implicitly
     * declared as defined by The Java Language
     * Specification.
     */
    public boolean isImplicit() {
        return Modifier.isMandated(getModifiers());
    }

    /**
     * Returns {@code true} if this parameter is neither implicitly
     * nor explicitly declared in source code; returns {@code false}
     * otherwise.
     *
     * @return true if and only if this parameter is a synthetic
     * construct as defined by
     * The Java Language Specification.
     * @jls 13.1 The Form of a Binary
     * @see Java
     * programming language and JVM modeling in core reflection
     */
    public boolean isSynthetic() {
        return Modifier.isSynthetic(getModifiers());
    }

    /**
     * Returns {@code true} if this parameter represents a variable
     * argument list; returns {@code false} otherwise.
     *
     * @return {@code true} if an only if this parameter represents a
     * variable argument list.
     */
    public boolean isVarArgs() {
        return executable.isVarArgs() &&
            index == executable.getParameterCount() - 1;
    }

    /**
     * {@inheritDoc}
     *
Note that any annotation returned by this method is a
     * declaration annotation.
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
        Objects.requireNonNull(annotationClass);
        return annotationClass.cast(declaredAnnotations().get(annotationClass));
    }

    /**
     * {@inheritDoc}
     *
Note that any annotations returned by this method are
     * declaration annotations.
     *
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
        Objects.requireNonNull(annotationClass);

        return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
    }

    /**
     * {@inheritDoc}
     *
Note that any annotations returned by this method are
     * declaration annotations.
     */
    @Override
    public Annotation[] getDeclaredAnnotations() {
        return executable.getParameterAnnotations()[index];
    }

    /**
     * {@inheritDoc}
     *
Note that any annotation returned by this method is a
     * declaration annotation.
     *
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
        // Only annotations on classes are inherited, for all other
        // objects getDeclaredAnnotation is the same as
        // getAnnotation.
        return getAnnotation(annotationClass);
    }

    /**
     * {@inheritDoc}
     *
Note that any annotations returned by this method are
     * declaration annotations.
     *
     * @throws NullPointerException {@inheritDoc}
     */
    @Override
    public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
        // Only annotations on classes are inherited, for all other
        // objects getDeclaredAnnotations is the same as
        // getAnnotations.
        return getAnnotationsByType(annotationClass);
    }

    /**
     * {@inheritDoc}
     *
Note that any annotations returned by this method are
     * declaration annotations.
     */
    @Override
    public Annotation[] getAnnotations() {
        return getDeclaredAnnotations();
    }

    private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;

    private synchronized Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {
        if(null == declaredAnnotations) {
            declaredAnnotations = new HashMap<>();
            for (Annotation a : getDeclaredAnnotations())
                declaredAnnotations.put(a.annotationType(), a);
        }
        return declaredAnnotations;
   }

}


text:
namespace Organizr.Web.Areas.Events.ViewModels
{
    using System;
    using System.Collections.Generic;

    using Infrastructure.Mapping;
    using Organizr.Data.Models;
    using Services.Web;

    public class EventDetailsViewModel : IMapFrom<Event>
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public string Description { get; set; }

        public User Organiser { get; set; }

        public DateTime? StartDate { get; set; }

        public Coordinates Coordinates { get; set; }

        public bool HasFinished { get; set; }

        public ICollection<User> Participants { get; set; }

        public ICollection<EventRate> EventRates { get; set; }

        public decimal Rate
        {
            get
            {
                if (this.EventRates.Count == 0)
                {
                    return 0;
                }

                decimal sum = 0;

                foreach (var rate in this.EventRates)
                {
                    sum += rate.Value;
                }

                decimal avgRate = sum / this.EventRates.Count;

                return avgRate;
            }
        }

        public string EncodedId
        {
            get
            {
                IIdentifierProvider identifier = new IdentifierProvider();
                return identifier.EncodeId(this.Id);
            }
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
require 'spec_helper'

describe Link do
  describe '#as_json' do
    it 'includes the author' do
      author = create(:author, name: 'bender', website: 'rod.com')
      link = create(:link, author: author, title: 'HA!', url: 'rod.com', description: 'Take that smelly human!', date: Date.today )
      expect(link.as_json).to eq({
        "id" => link.id,
        "title" => 'HA!',
        "url" => 'rod.com',
        "description" => 'Take that smelly human!',
        "date" => Date.today.iso8601,
        "author" => {
          "name" => 'bender',
          "website" => 'rod.com'
        }
      })
    end
  end
end


text:
namespace Votyra.Core.Images
{
    public interface IMask2eProvider
    {
        IMask2e CreateMask();
    }
}


text:
/* */
'use strict';
var SyntheticEvent = require('./SyntheticEvent');
var CompositionEventInterface = {data: null};
function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
  return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);
module.exports = SyntheticCompositionEvent;


text:
<?php

namespace denbora\R_T_G_Services\examples\SOAP\MessageCenter;

use denbora\R_T_G_Services\casino\Casino;

class GenerateMessageForPlayer
{
    /**
     * GenerateMessageForPlayer constructor.
     * @param string $service
     * @param string $method
     * @param Casino $casino
     */
    public function __construct(string $service, string $method, $casino)
    {
        try {
            $messageCenterService = $casino->getService($service);
            $inputs = array(
                'MessageID' => 1,
                'PID' => 10025652,
                'CasinoID' => 1,
                'Scheme' => '',
                'CashierURL' => '0',
                'TournamentURL' => '',
                'MpRouletteURL' => '',
                'PlayMode' => '',
                'ClientType' => ''
            );

            $result = $messageCenterService->call($method, $inputs);

            echo "
";
            var_dump($result);
            echo "
";
        } catch (\Exception $e) {
            echo "
";
            var_dump($e);
            echo "
";
        }
    }
}


text:
<?php

namespace Zimbra\Admin\Request;

/**
 * ModifyUCService request class
 * ModifyModify attributes for a UC service.
 *
 * @package    Zimbra
 * @subpackage Admin
 * @category   Request
 * @author     Nguyen Van Nguyen - nguyennv1981@gmail.com
 * @copyright  Copyright © 2013 by Nguyen Van Nguyen.
 */
class ModifyUCService extends BaseAttr
{
    /**
     * Constructor method for ModifyUCService
     * @param string $id Zimbra ID
     * @param array  $attrs
     * @return self
     */
    public function __construct($id, array $attrs = [])
    {
        parent::__construct($attrs);
        $this->setChild('id', trim($id));
    }

    /**
     * Gets Zimbra ID
     *
     * @return string
     */
    public function getId()
    {
        return $this->getChild('id');
    }

    /**
     * Sets Zimbra ID
     *
     * @param  string $id
     * @return self
     */
    public function setId($id)
    {
        return $this->setChild('id', trim($id));
    }
}


text:
/*
 * @flow
 * @lint-ignore-every LINE_WRAP1
 */

import {suite, test} from '../../tsrc/test/Tester';

export default suite(({addFile, addFiles, addCode}) => [
  test('local exports override remote exports', [
    addFile('./origin.js').noNewErrors(),
    addFile('./local_override1.js').noNewErrors(),

    addCode(`
      import {C} from "./local_override1";
      (C: string);
    `).noNewErrors(),

    addCode('(C: number);').newErrors(`
      test.js:8
        8: (C: number);
            ^ string. This type is incompatible with
        8: (C: number);
               ^^^^^^ number
    `),
  ]),

  test('local exports override remote exports regardless of export order', [
    addFile('./origin.js').noNewErrors(),
    addFile('./local_override2.js').noNewErrors(),

    addCode(`
      import {C} from "./local_override2";
      (C: string);
    `).noNewErrors(),

    addCode('(C: number);').newErrors(`
      test.js:8
        8: (C: number);
            ^ string. This type is incompatible with
        8: (C: number);
               ^^^^^^ number
    `),
  ]),
]);


text:
<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="http://www.netbeans.org/ns/library-declaration/3" version="3.0">
    <name>org.common</name>
    <type>j2se</type>
    <display-name>org.common</display-name>
    <volume>
        <type>classpath</type>
    </volume>
    <volume>
        <type>src</type>
    </volume>
    <volume>
        <type>javadoc</type>
    </volume>
    <volume>
        <type>maven-pom</type>
    </volume>
    <properties/>
</library>


text:
var common = require("./text-base-common");
var types = require("utils/types");
var TextBase = (function (_super) {
    __extends(TextBase, _super);
    function TextBase() {
        _super.apply(this, arguments);
    }
    TextBase.prototype._onTextPropertyChanged = function (data) {
        if (this.android) {
            var newValue = types.toUIString(data.newValue);
            this.android.setText(newValue);
        }
    };
    TextBase.prototype._setFormattedTextPropertyToNative = function (value) {
        var newText = value ? value._formattedText : null;
        if (this.android) {
            this.android.setText(newText);
        }
    };
    return TextBase;
}(common.TextBase));
exports.TextBase = TextBase;
//# sourceMappingURL=text-base.js.map


text:
<?php
namespace Chamilo\Core\Repository\ContentObject\Matterhorn\Integration\Chamilo\Core\Repository\ContentObject\LearningPath\Package;

class Deactivator extends \Chamilo\Configuration\Package\Action\Deactivator
{
}


text:
package org.keycloak.testsuite;

import org.keycloak.admin.client.resource.RealmResource;
import org.keycloak.common.util.reflections.Reflections;
import org.keycloak.events.Details;
import org.keycloak.representations.IDToken;
import org.keycloak.representations.idm.ClientRepresentation;
import org.keycloak.representations.idm.EventRepresentation;
import org.keycloak.representations.idm.RealmRepresentation;
import org.keycloak.representations.idm.UserRepresentation;
import org.keycloak.testsuite.util.OAuthClient;

import java.lang.reflect.Field;
import java.util.List;

import static org.keycloak.testsuite.admin.AbstractAdminTest.loadJson;

/**
 * This class provides loading of the testRealm called "test".  It also
 * provides a few utility methods for the testRealm.
 *
 * @author Stan Silvert ssilvert@redhat.com (C) 2016 Red Hat Inc.
 */
public abstract class AbstractTestRealmKeycloakTest extends AbstractKeycloakTest {

    protected RealmResource testRealm() {
        return adminClient.realm("test");
    }

    protected UserRepresentation findUser(String userNameOrEmail) {
        List<UserRepresentation> repList = testRealm().users().search(userNameOrEmail, -1, -1);
        if (repList.size() != 1) throw new IllegalStateException("User search expected one result. Found " + repList.size() + " users.");
        return repList.get(0);
    }

    protected void updateUser(UserRepresentation user) {
        testRealm().users().get(user.getId()).update(user);
    }

    protected ClientRepresentation findTestApp(RealmRepresentation testRealm) {
        for (ClientRepresentation client : testRealm.getClients()) {
            if (client.getClientId().equals("test-app")) return client;
        }

        return null;
    }

    @Override
    public void addTestRealms(List<RealmRepresentation> testRealms) {
        RealmRepresentation testRealm = loadJson(getClass().getResourceAsStream("/testrealm.json"), RealmRepresentation.class);

        testRealms.add(testRealm);

        configureTestRealm(testRealm);
    }

    /**
     * This allows a subclass to change the configuration of the testRealm before
     * it is imported.  This method will be called prior to any @Before methods
     * in the subclass.
     *
     * @param testRealm The realm read from /testrealm.json.
     */
    public abstract void configureTestRealm(RealmRepresentation testRealm);

    protected IDToken sendTokenRequestAndGetIDToken(EventRepresentation loginEvent) {
        String sessionId = loginEvent.getSessionId();
        String codeId = loginEvent.getDetails().get(Details.CODE_ID);

        String code = new OAuthClient.AuthorizationEndpointResponse(oauth).getCode();
        OAuthClient.AccessTokenResponse response = oauth.doAccessTokenRequest(code, "password");

        Assert.assertEquals(200, response.getStatusCode());
        IDToken idToken = oauth.verifyIDToken(response.getIdToken());

        Field eventsField = Reflections.findDeclaredField(this.getClass(), "events");
        if (eventsField != null) {
            AssertEvents events = Reflections.getFieldValue(eventsField, this, AssertEvents.class);
            events.expectCodeToToken(codeId, sessionId).assertEvent();
        }
        return idToken;
    }

}


text:
<?php

use yii\helpers\Html;
use app\module\handbook\models\DisciplineList;

/* @var $this yii\web\View */
/* @var $model app\module\handbook\models\Discipline */

$d_name = DisciplineList::findOne([$model->id_discipline]);
$this->title = 'Скопіювати дисципліну: ' . ' ' . $d_name['discipline_name'];
$this->params['breadcrumbs'][] = ['label' => 'Дисципліни', 'url' => ['index']];
$this->params['breadcrumbs'][] = ['label' => $d_name['discipline_name'], 'url' => ['view', 'id' => $model->discipline_distribution_id]];
$this->params['breadcrumbs'][] = 'Скопіювати';
?>

<?= Html::encode($this->title) ?>

    <?= $this->render('_form', [
        'model' => $model,
    ]) ?>


text:
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.execution.ui;

import com.intellij.icons.AllIcons;
import com.intellij.ui.ExperimentalUI;
import com.intellij.ui.IconReplacer;
import com.intellij.ui.IconWithOverlay;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Rectangle2D;
import java.util.Objects;

/**
 * @author Konstantin Bulenkov
 */
public class InvalidRunConfigurationIcon extends IconWithOverlay {
  public InvalidRunConfigurationIcon(@NotNull Icon runConfigurationIcon) {
    this(runConfigurationIcon, AllIcons.RunConfigurations.InvalidConfigurationLayer);
  }

  private InvalidRunConfigurationIcon(@NotNull Icon runConfigurationIcon, @NotNull Icon invalidConfigurationLayer) {
    super(runConfigurationIcon, invalidConfigurationLayer);
  }

  @Override
  public @Nullable Shape getOverlayShape(int x, int y) {
    if (ExperimentalUI.isNewUI()) {
      float scale = getScale();
      return new Rectangle2D.Float(x + scale * (16 - 7), y, 7 * scale, 7 * scale);
    }
    return null;
  }

  @NotNull
  @Override
  public InvalidRunConfigurationIcon replaceBy(@NotNull IconReplacer replacer) {
    return new InvalidRunConfigurationIcon(replacer.replaceIcon(Objects.requireNonNull(getIcon(0))),
                                           replacer.replaceIcon(Objects.requireNonNull(getIcon(1))));
  }
}


text:
try:
    int("foo")
except ValueError:
    pass


text:
package com.ufpb.questao2;

public class Pessoa {

	private String nome;
	private int idade;
	private Double altura;
	private Double peso;
	private String sexo;

	public Pessoa(){
		this.nome = "";
		this.idade = 0;
		this.altura = 0.0;
		this.peso = 0.0;
		this.sexo = "";
	}

	public Pessoa (String nome, int idade, Double altura, Double peso, String sexo){
		this.nome = nome;
		this.idade = idade;
		this.altura = altura;
		this.peso = peso;
		this.sexo = sexo;
	}

	public String getNome(){
		return this.nome;
	}

	public void setNome (String nome){
		this.nome = nome;
	}

	public int getIdade(){
		return this.idade;
	}

	public void setIdade(int idade){
		this.idade = idade;
	}

	public Double getAltura(){
		return this.altura;
	}

	public void setAltura(Double altura){
		this.altura = altura;
	}

	public Double getPeso(){
		return this.peso;
	}

	public void setPeso(Double peso){
		this.peso = peso;
	}

	public String getSexo(){
		return this.sexo;
	}

	public void setSexo (String sexo){
		this.sexo = sexo;
	}

	public Double calculaImc(Double peso, Double altura){
		return peso/(altura*altura);
	}

	public String toString(){
		Double imc = calculaImc(this.peso, this.altura);
		if (imc <= 18.5){
			return this.nome+" é uma pessoa do sexo "+this.sexo+" e está abaixo do seu peso normal. IMC: "+imc;
		} else if (18.5 < imc && imc <= 25.0){
			return this.nome+" é uma pessoa do sexo "+this.sexo+" e está com seu peso normal. IMC: "+imc;
		} else if (25.0 < imc && imc <= 30.0){
			return this.nome+" é uma pessoa do sexo "+this.sexo+" e está acima do peso normal. IMC: "+imc;
		} else {
			return this.nome+" é uma pessoa do sexo "+this.sexo+" e está com obesidade. IMC: "+imc;
		}

	}

}


text:
function import_from_url(url) {
  return $.get("/workshops/events/import/", {'url': url}, function(data) {
    $("#event_import_url").removeClass('is-invalid');
    $("#url_help").removeClass('invalid-feedback');
    $('#import_url_modal').modal('hide');
    $('#error_message').addClass('d-none');

    $("#id_slug").val(data.slug);
    $("#id_start").val(data.start);
    $("#id_end").val(data.end);
    $("#id_reg_key").val(data.reg_key);
    $("#id_url").val(url);

    // Select2 doesn't support programmatical search
    // so we're not going to fill the language for now

    // contact requires a couple of steps
    // 1. clear options
    $("#id_contact").find("option").remove();
    // 2. add options
    data.contact.forEach(element => {
      $("#id_contact").append(new Option(element, element, false, false))
    });
    // 3. select
    $("#id_contact").val(data.contact).trigger("change");

    $('#id_venue').val(data.venue);
    $('#id_address').val(data.address);
    $('#id_country').val(data.country);
    $('#id_latitude').val(data.latitude);
    $('#id_longitude').val(data.longitude);

    $("#id_comment").val(
      "INSTRUCTORS: " + data.instructors.join(", ") + "\n\n" +
      "HELPERS: " + data.helpers.join(", ")
    );
  });
}

function update_from_url(url, action) {
  return $.get("/workshops/events/import/", {'url': url}, function(data) {
    $("#event_update_url").removeClass('is-invalid');
    $("#url_help").removeClass('invalid-feedback');
    $('#update_url_modal').modal('hide');
    $('#error_message').addClass('d-none');

    switch (action) {
      case 'overwrite':
        $("#id_slug").val(data.slug);
        $("#id_start").val(data.start);
        $("#id_end").val(data.end);
        $("#id_reg_key").val(data.reg_key);
        $("#id_url").val(url);

        // Select2 doesn't support programmatical search
        // so we're not going to fill the language for now

        // contact requires a couple of steps
        // 1. clear options
        $("#id_contact").find("option").remove();
        // 2. add options
        data.contact.forEach(element => {
          $("#id_contact").append(new Option(element, element, false, false))
        });
        // 3. select
        $("#id_contact").val(data.contact).trigger("change");

        $('#id_venue').val(data.venue);
        $('#id_address').val(data.address);
        $('#id_country').val(data.country);
        $('#id_latitude').val(data.latitude);
        $('#id_longitude').val(data.longitude);
        $("#id_comment").val(
          "INSTRUCTORS: " + data.instructors.join(", ") + "\n\n" +
          "HELPERS: " + data.helpers.join(", ")
        );
        break;

      case 'skip':
      default:
        if ($("#id_slug").val() == "") {
          $("#id_slug").val(data.slug);
        }
        if ($("#id_start").val() == "") {
          $("#id_start").val(data.start);
        }
        if ($("#id_end").val() == "") {
          $("#id_end").val(data.end);
        }
        if ($("#id_reg_key").val() == "") {
          $("#id_reg_key").val(data.reg_key);
        }
        if ($("#id_url").val() == "") {
          $("#id_url").val(url);
        }
        if ($("#id_language").val() == "") {
          // Select2 doesn't support programmatical search
          // so we're not going to fill the language for now
        }
        if ($("#id_contact").val() == "") {
          // contact requires a couple of steps
          // 1. clear options
          $("#id_contact").find("option").remove();
          // 2. add options
          data.contact.forEach(element => {
            $("#id_contact").append(new Option(element, element, false, false))
          });
          // 3. select
          $("#id_contact").val(data.contact).trigger("change");
        }
        if ($("#id_venue").val() == "") {
          $("#id_venue").val(data.venue);
        }
        if ($("#id_address").val() == "") {
          $("#id_address").val(data.address);
        }
        if ($("#id_country").val() == "") {
          $("#id_country").val(data.country);
        }
        if ($("#id_latitude").val() == "") {
          $("#id_latitude").val(data.latitude);
        }
        if ($("#id_longitude").val() == "") {
          $("#id_longitude").val(data.longitude);
        }
        // save content in the comment
        $("#id_comment").val(
          $("#id_comment").val() +
          "INSTRUCTORS: " + data.instructors.join(", ") + "\n\n" +
          "HELPERS: " + data.helpers.join(", ")
        );

        break;
    }
  })
}

$(function() {
  $('#import_url_form').submit(function(e) {
    e.preventDefault();

    // indicate loading data
    var btn = $(this).find('button[type=submit]');
    btn.attr('disabled', true);

    // load data from URL
    import_from_url(
      $(this).find(':input[name=url]').val()
    )
    .fail(function(data) {
      // something went wrong, let's indicate it
      $("#event_import_url").addClass('is-invalid');
      $("#url_help").addClass('invalid-feedback');
      $('#error_message').text(data.responseText);
      $('#error_message').removeClass('d-none');
    })
    .always(function(data) {
      // let's always reenable the form's submit when the request finishes
      btn.attr('disabled', false);
    });
  });

  $('#update_url_form').submit(function(e) {
    e.preventDefault();

    // indicate loading data
    var btn = $(this).find('button[type=submit]');
    btn.attr('disabled', true);

    // load data from URL
    update_from_url(
      $(this).find(':input[name=url]').val(),
      $(this).find(':input[type=radio]:checked').val()
    )
    .fail(function(data) {
      // something went wrong, let's indicate it
      $("#event_update_url").addClass('is-invalid');
      $("#url_help").addClass('invalid-feedback');
      $('#error_message').text(data.responseText);
      $('#error_message').removeClass('d-none');
    })
    .always(function(data) {
      // let's always reenable the form's submit when the request finishes
      btn.attr('disabled', false);
    });
  });
});


text:
package net.minecraft.client.renderer.entity;

import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.BlockRendererDispatcher;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.texture.TextureMap;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.resources.model.IBakedModel;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityFallingBlock;
import net.minecraft.util.BlockPos;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;

public class RenderFallingBlock extends Render
{
    private static final String __OBFID = "CL_00000994";

    public RenderFallingBlock(RenderManager p_i46177_1_)
    {
        super(p_i46177_1_);
        this.shadowSize = 0.5F;
    }

    public void doRender(EntityFallingBlock p_180557_1_, double p_180557_2_, double p_180557_4_, double p_180557_6_, float p_180557_8_, float p_180557_9_)
    {
        if (p_180557_1_.getBlock() != null)
        {
            this.bindTexture(TextureMap.locationBlocksTexture);
            IBlockState var10 = p_180557_1_.getBlock();
            Block var11 = var10.getBlock();
            BlockPos var12 = new BlockPos(p_180557_1_);
            World var13 = p_180557_1_.getWorldObj();

            if (var10 != var13.getBlockState(var12) && var11.getRenderType() != -1)
            {
                if (var11.getRenderType() == 3)
                {
                    GlStateManager.pushMatrix();
                    GlStateManager.translate((float)p_180557_2_, (float)p_180557_4_, (float)p_180557_6_);
                    GlStateManager.disableLighting();
                    Tessellator var14 = Tessellator.getInstance();
                    WorldRenderer var15 = var14.getWorldRenderer();
                    var15.startDrawingQuads();
                    var15.setVertexFormat(DefaultVertexFormats.field_176600_a);
                    int var16 = var12.getX();
                    int var17 = var12.getY();
                    int var18 = var12.getZ();
                    var15.setTranslation((double)((float)(-var16) - 0.5F), (double)(-var17), (double)((float)(-var18) - 0.5F));
                    BlockRendererDispatcher var19 = Minecraft.getMinecraft().getBlockRendererDispatcher();
                    IBakedModel var20 = var19.getModelFromBlockState(var10, var13, (BlockPos)null);
                    var19.func_175019_b().renderBlockModel(var13, var20, var10, var12, var15, false);
                    var15.setTranslation(0.0D, 0.0D, 0.0D);
                    var14.draw();
                    GlStateManager.enableLighting();
                    GlStateManager.popMatrix();
                    super.doRender(p_180557_1_, p_180557_2_, p_180557_4_, p_180557_6_, p_180557_8_, p_180557_9_);
                }
            }
        }
    }

    /**
     * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
     */
    protected ResourceLocation getEntityTexture(EntityFallingBlock p_110775_1_)
    {
        return TextureMap.locationBlocksTexture;
    }

    /**
     * Returns the location of an entity's texture. Doesn't seem to be called unless you call Render.bindEntityTexture.
     */
    protected ResourceLocation getEntityTexture(Entity p_110775_1_)
    {
        return this.getEntityTexture((EntityFallingBlock)p_110775_1_);
    }

    /**
     * Actually renders the given argument. This is a synthetic bridge method, always casting down its argument and then
     * handing it off to a worker function which does the actual work. In all probabilty, the class Render is generic
     * (Render<T extends Entity) and this method has signature public void doRender(T entity, double d, double d1,
     * double d2, float f, float f1). But JAD is pre 1.5 so doesn't do that.
     */
    public void doRender(Entity p_76986_1_, double p_76986_2_, double p_76986_4_, double p_76986_6_, float p_76986_8_, float p_76986_9_)
    {
        this.doRender((EntityFallingBlock)p_76986_1_, p_76986_2_, p_76986_4_, p_76986_6_, p_76986_8_, p_76986_9_);
    }
}


text:
class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
  def initialize
    @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
  end

  # Produces a label for the given object without article.
  # @return [String] a human readable label
  #
  def label o
   @@label_visitor.visit(o)
  end

  def label_PObjectType o                       ; "#{Puppet::Pops::Types::TypeFactory.label(o)}" end
  def label_ProducerDescriptor o                ; "Producer"                                     end
  def label_NonCachingProducerDescriptor o      ; "Non Caching Producer"                         end
  def label_ConstantProducerDescriptor o        ; "Producer['#{o.value}']"                       end
  def label_EvaluatingProducerDescriptor o      ; "Evaluating Producer"                          end
  def label_InstanceProducerDescriptor o        ; "Producer[#{o.class_name}]"                    end
  def label_LookupProducerDescriptor o          ; "Lookup Producer[#{o.name}]"                   end
  def label_HashLookupProducerDescriptor o      ; "Hash Lookup Producer[#{o.name}][#{o.key}]"    end
  def label_FirstFoundProducerDescriptor o      ; "First Found Producer"                         end
  def label_ProducerProducerDescriptor o        ; "Producer[Producer]"                           end
  def label_MultibindProducerDescriptor o       ; "Multibind Producer"                           end
  def label_ArrayMultibindProducerDescriptor o  ; "Array Multibind Producer"                     end
  def label_HashMultibindProducerDescriptor o   ; "Hash Multibind Producer"                      end
  def label_Bindings o                          ; "Bindings"                                     end
  def label_NamedBindings o                     ; "Named Bindings"                               end
  def label_LayeredBindings o                   ; "Layered Bindings"                             end
  def label_NamedLayer o                        ; "Layer '#{o.name}'"                            end
  def label_ContributedBindings o               ; "Contributed Bindings"                         end
  def label_NamedArgument o                     ; "Named Argument"                               end

  def label_Binding(o)
    'Binding' + (o.multibind_id.nil? ? '' : ' In Multibind')
  end
  def label_Multibinding(o)
    'Multibinding' + (o.multibind_id.nil? ? '' : ' In Multibind')
  end

end


text:
Will be posting posts about random stuff, and technical blogs on my projects

https://www.dannguyen.me/


text:
bool VTorque::isLightObjectEnabled( LightObjectType *pLightObject )
{
    if ( !pLightObject )
    {
        // Sanity!
        return false;
    }

    // Get Enabled.
    return pLightObject->getLightEnabled();
}

void VTorque::setLightObjectOn( LightObjectType *pLightObject, const bool &pStatus )
{
    if ( !pLightObject )
    {
        // Sanity!
        return;
    }

    // Set Enabled.
    pLightObject->setLightEnabled( pStatus );
}

void VTorque::playAnimation( LightObjectType *pLightObject, LightAnimationDataType *pLightAnimationData )
{
    if ( !pLightObject || !pLightAnimationData )
    {
        // Sanity!
        return;
    }

    // Play Animation.
    pLightObject->playAnimation( pLightAnimationData );
}

void VTorque::playAnimation( LightObjectType *pLightObject )
{
    if ( !pLightObject )
    {
        // Sanity!
        return;
    }

    // Play Animation.
    pLightObject->playAnimation();
}

void VTorque::pauseAnimation( LightObjectType *pLightObject )
{
    if ( !pLightObject )
    {
        // Sanity!
        return;
    }

    // Play Animation.
    pLightObject->pauseAnimation();
}


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 Internal.Cryptography;
using System.Diagnostics;

namespace System.Security.Cryptography
{
    using BCRYPT_ECCFULLKEY_BLOB = Interop.BCrypt.BCRYPT_ECCFULLKEY_BLOB;
    using BCRYPT_ECCKEY_BLOB = Interop.BCrypt.BCRYPT_ECCKEY_BLOB;
    using ErrorCode = Interop.NCrypt.ErrorCode;
    using KeyBlobMagicNumber = Interop.BCrypt.KeyBlobMagicNumber;

    internal static partial class ECCng
    {
        private static CngKey ImportKeyBlob(byte[] ecBlob, ECCurve curve, bool includePrivateParameters)
        {
            CngKeyBlobFormat blobFormat = includePrivateParameters ? CngKeyBlobFormat.EccPrivateBlob : CngKeyBlobFormat.EccPublicBlob;
            CngKey newKey = CngKey.Import(ecBlob, curve, blobFormat);
            newKey.ExportPolicy |= CngExportPolicies.AllowPlaintextExport;

            return newKey;
        }

        private static CngKey ImportFullKeyBlob(byte[] ecBlob, bool includePrivateParameters)
        {
            CngKeyBlobFormat blobFormat = includePrivateParameters ? CngKeyBlobFormat.EccFullPrivateBlob : CngKeyBlobFormat.EccFullPublicBlob;
            CngKey newKey = CngKey.Import(ecBlob, blobFormat);
            newKey.ExportPolicy |= CngExportPolicies.AllowPlaintextExport;

            return newKey;
        }

        private static byte[] ExportKeyBlob(CngKey key, bool includePrivateParameters)
        {
            CngKeyBlobFormat blobFormat = includePrivateParameters ? CngKeyBlobFormat.EccPrivateBlob : CngKeyBlobFormat.EccPublicBlob;
            return key.Export(blobFormat);
        }

        private static byte[] ExportFullKeyBlob(CngKey key, bool includePrivateParameters)
        {
            CngKeyBlobFormat blobFormat = includePrivateParameters ? CngKeyBlobFormat.EccFullPrivateBlob : CngKeyBlobFormat.EccFullPublicBlob;
            return key.Export(blobFormat);
        }

        internal static CngKey ImportNamedCurveParameters(ECParameters parameters, bool includePrivateParameters)
        {
            Debug.Assert(parameters.Curve.IsNamed);

            unsafe
            {
                // We need to build a key blob structured as follows:
                //     BCRYPT_ECCKEY_BLOB   header
                //     byte[cbKey]          Q.X
                //     byte[cbKey]          Q.Y
                //     -- Only if "includePrivateParameters" is true --
                //     byte[cbKey]          D

                int blobSize = sizeof(BCRYPT_ECCKEY_BLOB) +
                    parameters.Q.X.Length +
                    parameters.Q.Y.Length;
                if (includePrivateParameters)
                {
                    blobSize += parameters.D.Length;
                }

                byte[] blob = new byte[blobSize];
                fixed (byte* pBlob = blob)
                {
                    // Build the header
                    BCRYPT_ECCKEY_BLOB* pBcryptBlob = (BCRYPT_ECCKEY_BLOB*)pBlob;
                    pBcryptBlob->Magic = CurveNameToMagicNumber(parameters.Curve.Oid.FriendlyName, includePrivateParameters);
                    pBcryptBlob->cbKey = parameters.Q.X.Length;

                    // Emit the blob
                    int offset = sizeof(BCRYPT_ECCKEY_BLOB);
                    Interop.BCrypt.Emit(blob, ref offset, parameters.Q.X);
                    Interop.BCrypt.Emit(blob, ref offset, parameters.Q.Y);
                    if (includePrivateParameters)
                    {
                        Interop.BCrypt.Emit(blob, ref offset, parameters.D);
                    }

                    // We better have computed the right allocation size above!
                    Debug.Assert(offset == blobSize, "offset == blobSize");
                }

                return ImportKeyBlob(blob, parameters.Curve, includePrivateParameters);
            }
        }

        internal static CngKey ImportPrimeCurveParameters(ECParameters parameters, bool includePrivateParameters)
        {
            Debug.Assert(parameters.Curve.IsPrime);

            ECCurve curve = parameters.Curve;

            unsafe
            {
                // We need to build a key blob structured as follows:
                //     BCRYPT_ECCFULLKEY_BLOB       header
                //     byte[cbFieldLength]          P
                //     byte[cbFieldLength]          A
                //     byte[cbFieldLength]          B
                //     byte[cbFieldLength]          G.X
                //     byte[cbFieldLength]          G.Y
                //     byte[cbSubgroupOrder]        Order (n)
                //     byte[cbCofactor]             Cofactor (h)
                //     byte[cbSeed]                 Seed
                //     byte[cbFieldLength]          Q.X
                //     byte[cbFieldLength]          Q.Y
                //     -- Only if "includePrivateParameters" is true --
                //     byte[cbSubgroupOrder]        D

                int blobSize = sizeof(BCRYPT_ECCFULLKEY_BLOB) +
                    curve.Prime.Length +
                    curve.A.Length +
                    curve.B.Length +
                    curve.G.X.Length +
                    curve.G.Y.Length +
                    curve.Order.Length +
                    curve.Cofactor.Length +
                    (curve.Seed == null ? 0 : curve.Seed.Length) +
                    parameters.Q.X.Length +
                    parameters.Q.Y.Length;

                if (includePrivateParameters)
                {
                    blobSize += parameters.D.Length;
                }

                byte[] blob = new byte[blobSize];
                fixed (byte* pBlob = blob)
                {
                    // Build the header
                    BCRYPT_ECCFULLKEY_BLOB* pBcryptBlob = (BCRYPT_ECCFULLKEY_BLOB*)pBlob;
                    pBcryptBlob->Version = 1; // No constant for this found in bcrypt.h
                    pBcryptBlob->Magic = includePrivateParameters ?
                        KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC :
                        KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC;
                    pBcryptBlob->cbCofactor = curve.Cofactor.Length;
                    pBcryptBlob->cbFieldLength = parameters.Q.X.Length;
                    pBcryptBlob->cbSeed = curve.Seed == null ? 0 : curve.Seed.Length;
                    pBcryptBlob->cbSubgroupOrder = curve.Order.Length;
                    pBcryptBlob->CurveGenerationAlgId = GetHashAlgorithmId(curve.Hash);
                    pBcryptBlob->CurveType = ConvertToCurveTypeEnum(curve.CurveType);

                    // Emit the blob
                    int offset = sizeof(BCRYPT_ECCFULLKEY_BLOB);
                    Interop.BCrypt.Emit(blob, ref offset, curve.Prime);
                    Interop.BCrypt.Emit(blob, ref offset, curve.A);
                    Interop.BCrypt.Emit(blob, ref offset, curve.B);
                    Interop.BCrypt.Emit(blob, ref offset, curve.G.X);
                    Interop.BCrypt.Emit(blob, ref offset, curve.G.Y);
                    Interop.BCrypt.Emit(blob, ref offset, curve.Order);
                    Interop.BCrypt.Emit(blob, ref offset, curve.Cofactor);
                    if (curve.Seed != null)
                    {
                        Interop.BCrypt.Emit(blob, ref offset, curve.Seed);
                    }
                    Interop.BCrypt.Emit(blob, ref offset, parameters.Q.X);
                    Interop.BCrypt.Emit(blob, ref offset, parameters.Q.Y);
                    if (includePrivateParameters)
                    {
                        Interop.BCrypt.Emit(blob, ref offset, parameters.D);
                    }

                    // We better have computed the right allocation size above!
                    Debug.Assert(offset == blobSize, "offset == blobSize");
                }

                return ImportFullKeyBlob(blob, includePrivateParameters);
            }
        }

        internal static ECParameters ExportNamedCurveParameters(CngKey key, bool includePrivateParameters)
        {
            byte[] ecBlob = ExportKeyBlob(key, includePrivateParameters);
            // We now have a buffer laid out as follows:
            //     BCRYPT_ECCKEY_BLOB   header
            //     byte[cbKey]          Q.X
            //     byte[cbKey]          Q.Y
            //     -- Private only --
            //     byte[cbKey]          D

            ECParameters ecParams = new ECParameters();

            KeyBlobMagicNumber magic = (KeyBlobMagicNumber)BitConverter.ToInt32(ecBlob, 0);

            // Check the magic value in the key blob header. If the blob does not have the required magic,
            // then throw a CryptographicException.
            CheckMagicValueOfKey(magic, includePrivateParameters);

            unsafe
            {
                // Fail-fast if a rogue provider gave us a blob that isn't even the size of the blob header.
                if (ecBlob.Length < sizeof(BCRYPT_ECCKEY_BLOB))
                    throw ErrorCode.E_FAIL.ToCryptographicException();

                fixed (byte* pEcBlob = ecBlob)
                {
                    BCRYPT_ECCKEY_BLOB* pBcryptBlob = (BCRYPT_ECCKEY_BLOB*)pEcBlob;

                    int offset = sizeof(BCRYPT_ECCKEY_BLOB);

                    ecParams.Q = new ECPoint
                    {
                        X = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbKey),
                        Y = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbKey)
                    };

                    if (includePrivateParameters)
                    {
                        ecParams.D = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbKey);
                    }
                }
            }

            ecParams.Curve = ECCurve.CreateFromFriendlyName(key.GetCurveName());

            return ecParams;
        }

        internal static ECParameters ExportPrimeCurveParameters(CngKey key, bool includePrivateParameters)
        {
            byte[] ecBlob = ExportFullKeyBlob(key, includePrivateParameters);
            // We now have a buffer laid out as follows:
            //     BCRYPT_ECCFULLKEY_BLOB       header
            //     byte[cbFieldLength]          P
            //     byte[cbFieldLength]          A
            //     byte[cbFieldLength]          B
            //     byte[cbFieldLength]          G.X
            //     byte[cbFieldLength]          G.Y
            //     byte[cbSubgroupOrder]        Order (n)
            //     byte[cbCofactor]             Cofactor (h)
            //     byte[cbSeed]                 Seed
            //     byte[cbFieldLength]          Q.X
            //     byte[cbFieldLength]          Q.Y
            //     -- Private only --
            //     byte[cbSubgroupOrder]        D

            ECParameters ecParams = new ECParameters();

            KeyBlobMagicNumber magic = (KeyBlobMagicNumber)BitConverter.ToInt32(ecBlob, 0);

            // Check the magic value in the key blob header. If the blob does not have the required magic,
            // then throw a CryptographicException.
            CheckMagicValueOfKey(magic, includePrivateParameters);

            unsafe
            {
                // Fail-fast if a rogue provider gave us a blob that isn't even the size of the blob header.
                if (ecBlob.Length < sizeof(BCRYPT_ECCFULLKEY_BLOB))
                    throw ErrorCode.E_FAIL.ToCryptographicException();

                fixed (byte* pEcBlob = ecBlob)
                {
                    BCRYPT_ECCFULLKEY_BLOB* pBcryptBlob = (BCRYPT_ECCFULLKEY_BLOB*)pEcBlob;

                    var primeCurve = new ECCurve();
                    primeCurve.CurveType = ConvertToCurveTypeEnum(pBcryptBlob->CurveType);
                    primeCurve.Hash = GetHashAlgorithmName(pBcryptBlob->CurveGenerationAlgId);

                    int offset = sizeof(BCRYPT_ECCFULLKEY_BLOB);

                    primeCurve.Prime = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength);
                    primeCurve.A = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength);
                    primeCurve.B = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength);
                    primeCurve.G = new ECPoint()
                    {
                        X = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength),
                        Y = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength),
                    };
                    primeCurve.Order = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbSubgroupOrder);
                    primeCurve.Cofactor = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbCofactor);

                    // Optional parameters
                    primeCurve.Seed = pBcryptBlob->cbSeed == 0 ? null : Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbSeed);

                    ecParams.Q = new ECPoint
                    {
                        X = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength),
                        Y = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbFieldLength)
                    };

                    if (includePrivateParameters)
                    {
                        ecParams.D = Interop.BCrypt.Consume(ecBlob, ref offset, pBcryptBlob->cbSubgroupOrder);
                    }

                    ecParams.Curve = primeCurve;
                    return ecParams;
                }
            }
        }

        /// <summary>
        ///     This function checks the magic value in the key blob header
        /// </summary>
        /// <param name="includePrivateParameters">Private blob if true else public key blob</param>
        private static void CheckMagicValueOfKey(KeyBlobMagicNumber magic, bool includePrivateParameters)
        {
            if (includePrivateParameters)
            {
                if (!IsMagicValueOfKeyPrivate(magic))
                {
                    throw new CryptographicException(SR.Cryptography_NotValidPrivateKey);
                }
            }
            else
            {
                if (!IsMagicValueOfKeyPublic(magic))
                {
                    throw new CryptographicException(SR.Cryptography_NotValidPublicOrPrivateKey);
                }
            }
        }

        private static bool IsMagicValueOfKeyPrivate(KeyBlobMagicNumber magic)
        {
            switch (magic)
            {
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P256_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PRIVATE_P256_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P384_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PRIVATE_P384_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P521_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PRIVATE_P521_MAGIC:
                    return true;
            }

            return false;
        }

        private static bool IsMagicValueOfKeyPublic(KeyBlobMagicNumber magic)
        {
            switch (magic)
            {
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P256_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PUBLIC_P256_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P384_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PUBLIC_P384_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P521_MAGIC:
                case KeyBlobMagicNumber.BCRYPT_ECDH_PUBLIC_P521_MAGIC:
                    return true;
            }

            // Private key magic is permissible too since the public key can be derived from the private key blob.
            return IsMagicValueOfKeyPrivate(magic);
        }

        /// <summary>
        /// Map a curve name to magic number. Maps the names of the curves that worked pre-Win10
        /// to the pre-Win10 magic numbers to support import on pre-Win10 environments
        /// that don't have the named curve functionality.
        /// </summary>
        private static KeyBlobMagicNumber CurveNameToMagicNumber(string name, bool includePrivateParameters)
        {
            CngAlgorithm alg = CngKey.EcdsaCurveNameToAlgorithm(name);
            if (alg == CngAlgorithm.ECDsaP256)
            {
                return includePrivateParameters ?
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P256_MAGIC :
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
            }

            if (alg == CngAlgorithm.ECDsaP384)
            {
                return includePrivateParameters ?
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P384_MAGIC :
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P384_MAGIC;
            }

            if (alg == CngAlgorithm.ECDsaP521)
            {
                return includePrivateParameters ?
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_P521_MAGIC :
                    KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_P521_MAGIC;
            }

            // all other curves are new in Win10 so use named curves
            return includePrivateParameters ?
                KeyBlobMagicNumber.BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC :
                KeyBlobMagicNumber.BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC;
        }

        /// <summary>
        /// Helper method to map between BCrypt.ECC_CURVE_TYPE_ENUM and ECCurve.ECCurveType
        /// </summary>
        internal static Interop.BCrypt.ECC_CURVE_TYPE_ENUM ConvertToCurveTypeEnum(ECCurve.ECCurveType value)
        {
            // Currently values 1-3 are interchangeable
            Debug.Assert(value == ECCurve.ECCurveType.Characteristic2 ||
                value == ECCurve.ECCurveType.PrimeShortWeierstrass ||
                value == ECCurve.ECCurveType.PrimeTwistedEdwards);
            return (Interop.BCrypt.ECC_CURVE_TYPE_ENUM)value;
        }

        /// <summary>
        /// Helper method to map between BCrypt.ECC_CURVE_TYPE_ENUM and ECCurve.ECCurveType
        /// </summary>
        internal static ECCurve.ECCurveType ConvertToCurveTypeEnum(Interop.BCrypt.ECC_CURVE_TYPE_ENUM value)
        {
            // Currently values 1-3 are interchangeable
            ECCurve.ECCurveType curveType = (ECCurve.ECCurveType)value;
            Debug.Assert(curveType == ECCurve.ECCurveType.Characteristic2 ||
                curveType == ECCurve.ECCurveType.PrimeShortWeierstrass ||
                curveType == ECCurve.ECCurveType.PrimeTwistedEdwards);
            return curveType;
        }
    }
}


text:
@interface YUGLFlyeyeTransitionFilter : GPUImageTwoInputFilter <YUGLTransitionFilter>
@property (nonatomic) CGFloat progress;
@property (nonatomic) CGFloat size;
@property (nonatomic) CGFloat zoom;
@end


text:
'use strict';

var Syncher = require('../../syncher');

var each = require('../../each');

function selectArticles() {
	var client = this;
	var args = Array.prototype.slice.call(arguments);
	var callback = args.pop();
	var opts = args.pop() || {};
	var key = args.shift();
	function done(err, arr) {
		if (err) return callback(err);
		var syncher = new Syncher();
		var categories = {};
		arr.forEach(function (obj) {
			obj.category && (categories[obj.category] = null);
			if (!opts.withCommentList) return ;
			syncher.add(function (fn) {
				client.selectObjects('article:' + obj.id + ':comment', {limit: -1}, function (err, arr) {
					obj.comment_list = arr;
					fn(err);
				});
			});
		});
		each(categories, function (val, key) {
			syncher.add(function (fn) {
				client.getObject('category', key, function (err, obj) {
					categories[key] = obj;
					fn(err);
				});
			});
		});
		syncher.run(function () {
			for (var key = 0 ; key < arguments.length ; ++key) {
				var err = arguments[key][0];
				if (err) return callback(err);
			}
			arr.forEach(function (obj) {
				obj.category && (obj.category = categories[obj.category]);
			});
			callback(null, arr);
		});
	}
	if (!opts.id) return client.selectObjects((key ? key + ':' : '') + 'article', opts, done);
	client.getObject('article', opts.id, function (err, obj) {
		done(err, [obj]);
	});
}

module.exports = selectArticles;


text:
#ifndef PRIVATE_H

#define PRIVATE_H

/*
** This file is in the public domain, so clarified as of
** 1996-06-05 by Arthur David Olson.
*/

/*
** This header is for use ONLY with the time conversion code.
** There is no guarantee that it will remain unchanged,
** or that it will remain at all.
** Do NOT copy it to any system include directory.
** Thank you!
*/

#define GRANDPARENTED	"Local time zone must be set--see zic manual page"

/*
** Defaults for preprocessor symbols.
** You can override these in your C compiler options, e.g. '-DHAVE_GETTEXT=1'.
*/

#ifndef HAVE_DECL_ASCTIME_R
#define HAVE_DECL_ASCTIME_R 1
#endif

#ifndef HAVE_GETTEXT
#define HAVE_GETTEXT		0
#endif /* !defined HAVE_GETTEXT */

#ifndef HAVE_INCOMPATIBLE_CTIME_R
#define HAVE_INCOMPATIBLE_CTIME_R	0
#endif /* !defined INCOMPATIBLE_CTIME_R */

#ifndef HAVE_LINK
#define HAVE_LINK		1
#endif /* !defined HAVE_LINK */

#ifndef HAVE_POSIX_DECLS
#define HAVE_POSIX_DECLS 1
#endif

#ifndef HAVE_STRDUP
#define HAVE_STRDUP 1
#endif

#ifndef HAVE_SYMLINK
#define HAVE_SYMLINK		1
#endif /* !defined HAVE_SYMLINK */

#ifndef HAVE_SYS_STAT_H
#define HAVE_SYS_STAT_H		1
#endif /* !defined HAVE_SYS_STAT_H */

#ifndef HAVE_SYS_WAIT_H
#define HAVE_SYS_WAIT_H		1
#endif /* !defined HAVE_SYS_WAIT_H */

#ifndef HAVE_UNISTD_H
#define HAVE_UNISTD_H		1
#endif /* !defined HAVE_UNISTD_H */

#ifndef HAVE_UTMPX_H
#define HAVE_UTMPX_H		1
#endif /* !defined HAVE_UTMPX_H */

#ifndef NETBSD_INSPIRED
# define NETBSD_INSPIRED 1
#endif

#if HAVE_INCOMPATIBLE_CTIME_R
#define asctime_r _incompatible_asctime_r
#define ctime_r _incompatible_ctime_r
#endif /* HAVE_INCOMPATIBLE_CTIME_R */

/* Enable tm_gmtoff and tm_zone on GNUish systems.  */
#define _GNU_SOURCE 1
/* Fix asctime_r on Solaris 10.  */
#define _POSIX_PTHREAD_SEMANTICS 1
/* Enable strtoimax on Solaris 10.  */
#define __EXTENSIONS__ 1

/*
** Nested includes
*/

/* Avoid clashes with NetBSD by renaming NetBSD's declarations.  */
#define localtime_rz sys_localtime_rz
#define mktime_z sys_mktime_z
#define posix2time_z sys_posix2time_z
#define time2posix_z sys_time2posix_z
#define timezone_t sys_timezone_t
#define tzalloc sys_tzalloc
#define tzfree sys_tzfree
#include <time.h>
#undef localtime_rz
#undef mktime_z
#undef posix2time_z
#undef time2posix_z
#undef timezone_t
#undef tzalloc
#undef tzfree

#include "sys/types.h"	/* for time_t */
#include "stdio.h"
#include "string.h"
#include "limits.h"	/* for CHAR_BIT et al. */
#include "stdlib.h"

#include "errno.h"

#ifndef ENAMETOOLONG
# define ENAMETOOLONG EINVAL
#endif
#ifndef ENOTSUP
# define ENOTSUP EINVAL
#endif
#ifndef EOVERFLOW
# define EOVERFLOW EINVAL
#endif

#if HAVE_GETTEXT
#include "libintl.h"
#endif /* HAVE_GETTEXT */

#if HAVE_SYS_WAIT_H
#include <sys/wait.h>	/* for WIFEXITED and WEXITSTATUS */
#endif /* HAVE_SYS_WAIT_H */

#ifndef WIFEXITED
#define WIFEXITED(status)	(((status) & 0xff) == 0)
#endif /* !defined WIFEXITED */
#ifndef WEXITSTATUS
#define WEXITSTATUS(status)	(((status) >> 8) & 0xff)
#endif /* !defined WEXITSTATUS */

#if HAVE_UNISTD_H
#include "unistd.h"	/* for F_OK, R_OK, and other POSIX goodness */
#endif /* HAVE_UNISTD_H */

#ifndef HAVE_STRFTIME_L
# if _POSIX_VERSION < 200809
#  define HAVE_STRFTIME_L 0
# else
#  define HAVE_STRFTIME_L 1
# endif
#endif

#ifndef F_OK
#define F_OK	0
#endif /* !defined F_OK */
#ifndef R_OK
#define R_OK	4
#endif /* !defined R_OK */

/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */
#define is_digit(c) ((unsigned)(c) - '0' <= 9)

/*
** Define HAVE_STDINT_H's default value here, rather than at the
** start, since __GLIBC__'s value depends on previously-included
** files.
** (glibc 2.1 and later have stdint.h, even with pre-C99 compilers.)
*/
#ifndef HAVE_STDINT_H
#define HAVE_STDINT_H \
   (199901 <= __STDC_VERSION__ \
    || 2 < __GLIBC__ + (1 <= __GLIBC_MINOR__)	\
    || __CYGWIN__)
#endif /* !defined HAVE_STDINT_H */

#if HAVE_STDINT_H
#include "stdint.h"
#endif /* !HAVE_STDINT_H */

#ifndef HAVE_INTTYPES_H
# define HAVE_INTTYPES_H HAVE_STDINT_H
#endif
#if HAVE_INTTYPES_H
# include <inttypes.h>
#endif

/* Pre-C99 GCC compilers define __LONG_LONG_MAX__ instead of LLONG_MAX.  */
#ifdef __LONG_LONG_MAX__
# ifndef LLONG_MAX
#  define LLONG_MAX __LONG_LONG_MAX__
# endif
# ifndef LLONG_MIN
#  define LLONG_MIN (-1 - LLONG_MAX)
# endif
#endif

#ifndef INT_FAST64_MAX
# ifdef LLONG_MAX
typedef long long	int_fast64_t;
#  define INT_FAST64_MIN LLONG_MIN
#  define INT_FAST64_MAX LLONG_MAX
# else
#  if LONG_MAX >> 31 < 0xffffffff
Please use a compiler that supports a 64-bit integer type (or wider);
you may need to compile with "-DHAVE_STDINT_H".
#  endif
typedef long		int_fast64_t;
#  define INT_FAST64_MIN LONG_MIN
#  define INT_FAST64_MAX LONG_MAX
# endif
#endif

#ifndef SCNdFAST64
# if INT_FAST64_MAX == LLONG_MAX
#  define SCNdFAST64 "lld"
# else
#  define SCNdFAST64 "ld"
# endif
#endif

#ifndef INT_FAST32_MAX
# if INT_MAX >> 31 == 0
typedef long int_fast32_t;
#  define INT_FAST32_MAX LONG_MAX
#  define INT_FAST32_MIN LONG_MIN
# else
typedef int int_fast32_t;
#  define INT_FAST32_MAX INT_MAX
#  define INT_FAST32_MIN INT_MIN
# endif
#endif

#ifndef INTMAX_MAX
# ifdef LLONG_MAX
typedef long long intmax_t;
#  define strtoimax strtoll
#  define INTMAX_MAX LLONG_MAX
#  define INTMAX_MIN LLONG_MIN
# else
typedef long intmax_t;
#  define strtoimax strtol
#  define INTMAX_MAX LONG_MAX
#  define INTMAX_MIN LONG_MIN
# endif
#endif

#ifndef PRIdMAX
# if INTMAX_MAX == LLONG_MAX
#  define PRIdMAX "lld"
# else
#  define PRIdMAX "ld"
# endif
#endif

#ifndef UINT_FAST64_MAX
# if defined ULLONG_MAX || defined __LONG_LONG_MAX__
typedef unsigned long long uint_fast64_t;
# else
#  if ULONG_MAX >> 31 >> 1 < 0xffffffff
Please use a compiler that supports a 64-bit integer type (or wider);
you may need to compile with "-DHAVE_STDINT_H".
#  endif
typedef unsigned long	uint_fast64_t;
# endif
#endif

#ifndef UINTMAX_MAX
# if defined ULLONG_MAX || defined __LONG_LONG_MAX__
typedef unsigned long long uintmax_t;
# else
typedef unsigned long uintmax_t;
# endif
#endif

#ifndef PRIuMAX
# if defined ULLONG_MAX || defined __LONG_LONG_MAX__
#  define PRIuMAX "llu"
# else
#  define PRIuMAX "lu"
# endif
#endif

#ifndef INT32_MAX
#define INT32_MAX 0x7fffffff
#endif /* !defined INT32_MAX */
#ifndef INT32_MIN
#define INT32_MIN (-1 - INT32_MAX)
#endif /* !defined INT32_MIN */

#ifndef SIZE_MAX
#define SIZE_MAX ((size_t) -1)
#endif

#if 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
# define ATTRIBUTE_CONST __attribute__ ((const))
# define ATTRIBUTE_PURE __attribute__ ((__pure__))
# define ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))
#else
# define ATTRIBUTE_CONST /* empty */
# define ATTRIBUTE_PURE /* empty */
# define ATTRIBUTE_FORMAT(spec) /* empty */
#endif

#if !defined _Noreturn && __STDC_VERSION__ < 201112
# if 2 < __GNUC__ + (8 <= __GNUC_MINOR__)
#  define _Noreturn __attribute__ ((__noreturn__))
# else
#  define _Noreturn
# endif
#endif

#if __STDC_VERSION__ < 199901 && !defined restrict
# define restrict /* empty */
#endif

/*
** Workarounds for compilers/systems.
*/

/*
** Compile with -Dtime_tz=T to build the tz package with a private
** time_t type equivalent to T rather than the system-supplied time_t.
** This debugging feature can test unusual design decisions
** (e.g., time_t wider than 'long', or unsigned time_t) even on
** typical platforms.
*/
#ifdef time_tz
# ifdef LOCALTIME_IMPLEMENTATION
static time_t sys_time(time_t *x) { return time(x); }
# endif

typedef time_tz tz_time_t;

# undef  ctime
# define ctime tz_ctime
# undef  ctime_r
# define ctime_r tz_ctime_r
# undef  difftime
# define difftime tz_difftime
# undef  gmtime
# define gmtime tz_gmtime
# undef  gmtime_r
# define gmtime_r tz_gmtime_r
# undef  localtime
# define localtime tz_localtime
# undef  localtime_r
# define localtime_r tz_localtime_r
# undef  localtime_rz
# define localtime_rz tz_localtime_rz
# undef  mktime
# define mktime tz_mktime
# undef  mktime_z
# define mktime_z tz_mktime_z
# undef  offtime
# define offtime tz_offtime
# undef  posix2time
# define posix2time tz_posix2time
# undef  posix2time_z
# define posix2time_z tz_posix2time_z
# undef  time
# define time tz_time
# undef  time2posix
# define time2posix tz_time2posix
# undef  time2posix_z
# define time2posix_z tz_time2posix_z
# undef  time_t
# define time_t tz_time_t
# undef  timegm
# define timegm tz_timegm
# undef  timelocal
# define timelocal tz_timelocal
# undef  timeoff
# define timeoff tz_timeoff
# undef  tzalloc
# define tzalloc tz_tzalloc
# undef  tzfree
# define tzfree tz_tzfree
# undef  tzset
# define tzset tz_tzset
# undef  tzsetwall
# define tzsetwall tz_tzsetwall

char *ctime(time_t const *);
char *ctime_r(time_t const *, char *);
double difftime(time_t, time_t);
struct tm *gmtime(time_t const *);
struct tm *gmtime_r(time_t const *restrict, struct tm *restrict);
struct tm *localtime(time_t const *);
struct tm *localtime_r(time_t const *restrict, struct tm *restrict);
time_t mktime(struct tm *);
time_t time(time_t *);
void tzset(void);
#endif

#if !HAVE_DECL_ASCTIME_R && !defined asctime_r
extern char *asctime_r(struct tm const *restrict, char *restrict);
#endif

#if !HAVE_POSIX_DECLS
# ifdef USG_COMPAT
#  ifndef timezone
extern long timezone;
#  endif
#  ifndef daylight
extern int daylight;
#  endif
# endif
#endif

#if defined ALTZONE && !defined altzone
extern long altzone;
#endif

/*
** The STD_INSPIRED functions are similar, but most also need
** declarations if time_tz is defined.
*/

#ifdef STD_INSPIRED
# if !defined tzsetwall || defined time_tz
void tzsetwall(void);
# endif
# if !defined offtime || defined time_tz
struct tm *offtime(time_t const *, long);
# endif
# if !defined timegm || defined time_tz
time_t timegm(struct tm *);
# endif
# if !defined timelocal || defined time_tz
time_t timelocal(struct tm *);
# endif
# if !defined timeoff || defined time_tz
time_t timeoff(struct tm *, long);
# endif
# if !defined time2posix || defined time_tz
time_t time2posix(time_t);
# endif
# if !defined posix2time || defined time_tz
time_t posix2time(time_t);
# endif
#endif

/* Infer TM_ZONE on systems where this information is known, but suppress
   guessing if NO_TM_ZONE is defined.  Similarly for TM_GMTOFF.  */
#if (defined __GLIBC__ \
     || defined __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ \
     || (defined __APPLE__ && defined __MACH__))
# if !defined TM_GMTOFF && !defined NO_TM_GMTOFF
#  define TM_GMTOFF tm_gmtoff
# endif
# if !defined TM_ZONE && !defined NO_TM_ZONE
#  define TM_ZONE tm_zone
# endif
#endif

/*
** Define functions that are ABI compatible with NetBSD but have
** better prototypes.  NetBSD 6.1.4 defines a pointer type timezone_t
** and labors under the misconception that 'const timezone_t' is a
** pointer to a constant.  This use of 'const' is ineffective, so it
** is not done here.  What we call 'struct state' NetBSD calls
** 'struct __state', but this is a private name so it doesn't matter.
*/
#if NETBSD_INSPIRED
typedef struct state *timezone_t;
struct tm *localtime_rz(timezone_t restrict, time_t const *restrict,
			struct tm *restrict);
time_t mktime_z(timezone_t restrict, struct tm *restrict);
timezone_t tzalloc(char const *);
void tzfree(timezone_t);
# ifdef STD_INSPIRED
#  if !defined posix2time_z || defined time_tz
time_t posix2time_z(timezone_t, time_t) ATTRIBUTE_PURE;
#  endif
#  if !defined time2posix_z || defined time_tz
time_t time2posix_z(timezone_t, time_t) ATTRIBUTE_PURE;
#  endif
# endif
#endif

/*
** Finally, some convenience items.
*/

#if __STDC_VERSION__ < 199901
# define true 1
# define false 0
# define bool int
#else
# include <stdbool.h>
#endif

#ifndef TYPE_BIT
#define TYPE_BIT(type)	(sizeof (type) * CHAR_BIT)
#endif /* !defined TYPE_BIT */

#ifndef TYPE_SIGNED
#define TYPE_SIGNED(type) (((type) -1) < 0)
#endif /* !defined TYPE_SIGNED */

#define TWOS_COMPLEMENT(t) ((t) ~ (t) 0 < 0)

/* Max and min values of the integer type T, of which only the bottom
   B bits are used, and where the highest-order used bit is considered
   to be a sign bit if T is signed.  */
#define MAXVAL(t, b)						\
  ((t) (((t) 1 << ((b) - 1 - TYPE_SIGNED(t)))			\
	- 1 + ((t) 1 << ((b) - 1 - TYPE_SIGNED(t)))))
#define MINVAL(t, b)						\
  ((t) (TYPE_SIGNED(t) ? - TWOS_COMPLEMENT(t) - MAXVAL(t, b) : 0))

/* The minimum and maximum finite time values.  This assumes no padding.  */
static time_t const time_t_min = MINVAL(time_t, TYPE_BIT(time_t));
static time_t const time_t_max = MAXVAL(time_t, TYPE_BIT(time_t));

#ifndef INT_STRLEN_MAXIMUM
/*
** 302 / 1000 is log10(2.0) rounded up.
** Subtract one for the sign bit if the type is signed;
** add one for integer division truncation;
** add one more for a minus sign if the type is signed.
*/
#define INT_STRLEN_MAXIMUM(type) \
	((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \
	1 + TYPE_SIGNED(type))
#endif /* !defined INT_STRLEN_MAXIMUM */

/*
** INITIALIZE(x)
*/

#ifdef lint
# define INITIALIZE(x)	((x) = 0)
#else
# define INITIALIZE(x)
#endif

#ifndef UNINIT_TRAP
# define UNINIT_TRAP 0
#endif

/*
** For the benefit of GNU folk...
** '_(MSGID)' uses the current locale's message library string for MSGID.
** The default is to use gettext if available, and use MSGID otherwise.
*/

#ifndef _
#if HAVE_GETTEXT
#define _(msgid) gettext(msgid)
#else /* !HAVE_GETTEXT */
#define _(msgid) msgid
#endif /* !HAVE_GETTEXT */
#endif /* !defined _ */

#if !defined TZ_DOMAIN && defined HAVE_GETTEXT
# define TZ_DOMAIN "tz"
#endif

#if HAVE_INCOMPATIBLE_CTIME_R
#undef asctime_r
#undef ctime_r
char *asctime_r(struct tm const *, char *);
char *ctime_r(time_t const *, char *);
#endif /* HAVE_INCOMPATIBLE_CTIME_R */

#ifndef YEARSPERREPEAT
#define YEARSPERREPEAT		400	/* years before a Gregorian repeat */
#endif /* !defined YEARSPERREPEAT */

/*
** The Gregorian year averages 365.2425 days, which is 31556952 seconds.
*/

#ifndef AVGSECSPERYEAR
#define AVGSECSPERYEAR		31556952L
#endif /* !defined AVGSECSPERYEAR */

#ifndef SECSPERREPEAT
#define SECSPERREPEAT		((int_fast64_t) YEARSPERREPEAT * (int_fast64_t) AVGSECSPERYEAR)
#endif /* !defined SECSPERREPEAT */

#ifndef SECSPERREPEAT_BITS
#define SECSPERREPEAT_BITS	34	/* ceil(log2(SECSPERREPEAT)) */
#endif /* !defined SECSPERREPEAT_BITS */

#endif /* !defined PRIVATE_H */


text:
package com.mossle.auth.data;

import java.util.List;

import com.mossle.auth.persistence.domain.Perm;
import com.mossle.auth.persistence.domain.Role;
import com.mossle.auth.persistence.domain.RoleDef;
import com.mossle.auth.persistence.manager.PermManager;
import com.mossle.auth.persistence.manager.RoleDefManager;
import com.mossle.auth.persistence.manager.RoleManager;

import com.mossle.core.csv.CsvCallback;

public class OpenRoleCallback implements CsvCallback {
    private String openAppCode;
    private PermManager permManager;
    private RoleManager roleManager;
    private RoleDefManager roleDefManager;

    public void process(List<String> list, int lineNo) throws Exception {
        String name = list.get(0);
        String permission = list.get(1);
        RoleDef roleDef = this.findRoleDef(name);

        if (roleDef == null) {
            roleDef = new RoleDef();
            roleDef.setName(name);
            roleDef.setTenantId(openAppCode);
            roleDefManager.save(roleDef);
        }

        Role role = this.findRole(roleDef);

        if (role == null) {
            role = new Role();
            role.setName(name);
            role.setRoleDef(roleDef);
            role.setTenantId(openAppCode);
            roleManager.save(role);
        }

        for (String text : permission.split(",")) {
            Perm perm = this.findPerm(text);

            if (perm == null) {
                continue;
            }

            roleDef.getPerms().add(perm);
            roleDefManager.save(roleDef);
            permManager.save(perm);
        }
    }

    public RoleDef findRoleDef(String name) {
        String hql = "from RoleDef where name=? and tenantId=?";
        RoleDef roleDef = this.roleDefManager
                .findUnique(hql, name, openAppCode);

        return roleDef;
    }

    public Role findRole(RoleDef roleDef) {
        String hql = "from Role where roleDef=? and tenantId=?";
        Role role = this.roleManager.findUnique(hql, roleDef, openAppCode);

        return role;
    }

    public Perm findPerm(String code) {
        String hql = "from Perm where code=? and tenantId=?";
        Perm perm = this.permManager.findUnique(hql, code, openAppCode);

        return perm;
    }

    // ~
    public void setOpenAppCode(String openAppCode) {
        this.openAppCode = openAppCode;
    }

    public void setPermManager(PermManager permManager) {
        this.permManager = permManager;
    }

    public void setRoleManager(RoleManager roleManager) {
        this.roleManager = roleManager;
    }

    public void setRoleDefManager(RoleDefManager roleDefManager) {
        this.roleDefManager = roleDefManager;
    }
}