text:
<?php

namespace EightPoints\Bundle\GuzzleBundle\DependencyInjection;

use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
use Symfony\Component\ExpressionLanguage\Expression;

/**
 * @version   1.0
 * @since     2013-10
 */
class GuzzleExtension extends Extension
{
    protected $logFormatter;

    /**
     * Loads the Guzzle configuration.
     *
     * @version 1.0
     * @since   2013-10
     *
     * @param   array            $configs   an array of configuration settings
     * @param   ContainerBuilder $container a ContainerBuilder instance
     *
     * @throws  \InvalidArgumentException
     * @throws  \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws  \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     * @throws  \Exception
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configPath = implode(DIRECTORY_SEPARATOR, array(__DIR__, '..', 'Resources', 'config'));
        $loader     = new XmlFileLoader($container, new FileLocator($configPath));

        $loader->load('services.xml');

        $processor     = new Processor();
        $configuration = new Configuration($this->getAlias(), $container->getParameter('kernel.debug'));
        $config        = $processor->processConfiguration($configuration, $configs);

        $this->createLogger($config, $container);

        foreach ($config['clients'] as $name => $options) {

            $argument = [
                'base_uri' => $options['base_url'],
                'handler'  => $this->createHandler($container, $name, $options)
            ];

            // if present, add default options to the constructor argument for the Guzzle client
            if (array_key_exists('options', $options) && is_array($options['options'])) {
                foreach ($options['options'] as $key => $value) {
                    if ($value === null || (is_array($value) && count($value) === 0)) {
                        continue;
                    }

                    $argument[$key] = $value;
                }
            }

            $client = new Definition('%guzzle.http_client.class%');
            $client->addArgument($argument);

            // set service name based on client name
            $serviceName = sprintf('%s.client.%s', $this->getAlias(), $name);
            $container->setDefinition($serviceName, $client);
        }
    }

    /**
     * @since  2015-07
     *
     * @param  ContainerBuilder $container
     * @param  string           $name
     * @param  array            $config
     *
     * @return Definition
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     */
    protected function createHandler(ContainerBuilder $container, $name, array $config)
    {
        $logServiceName = sprintf('guzzle_bundle.middleware.log.%s', $name);
        $log = $this->createLogMiddleware();
        $container->setDefinition($logServiceName, $log);

        $headerServiceName = sprintf('guzzle_bundle.middleware.request_header.%s', $name);
        $requestHeader = $this->createRequestHeaderMiddleware($config['headers']);
        $container->setDefinition($headerServiceName, $requestHeader);

        // Event Dispatching service
        $eventServiceName = sprintf('guzzle_bundle.middleware.event_dispatch.%s', $name);
        $eventService = $this->createEventMiddleware($name);
        $container->setDefinition($eventServiceName, $eventService);

        $headerExpression = new Expression(sprintf("service('%s').attach()", $headerServiceName));
        $logExpression    = new Expression(sprintf("service('%s').log()", $logServiceName));
        // Create the event Dispatch Middleware
        $eventExpression  = new Expression(sprintf("service('%s').dispatchEvent()", $eventServiceName));

        $handler = new Definition('GuzzleHttp\HandlerStack');
        $handler->setFactory(['GuzzleHttp\HandlerStack', 'create']);

        // Plugins
        if (isset($config['plugin'])){
            // Wsse if required
            if (isset($config['plugin']['wsse'])
                && $config['plugin']['wsse']['username']
                && $config['plugin']['wsse']['password']) {

                $wsseConfig = $config['plugin']['wsse'];
                unset($config['plugin']['wsse']);

                $username = $wsseConfig['username'];
                $password = $wsseConfig['password'];
                $createdAtExpression = null;

                if (isset($wsseConfig['created_at']) && $wsseConfig['created_at']) {
                    $createdAtExpression = $wsseConfig['created_at'];
                }

                $wsse = $this->createWsseMiddleware($username, $password, $createdAtExpression);
                $wsseServiceName = sprintf('guzzle_bundle.middleware.wsse.%s', $name);

                $container->setDefinition($wsseServiceName, $wsse);

                $wsseExpression = new Expression(sprintf('service("%s").attach()', $wsseServiceName));

                $handler->addMethodCall('push', [$wsseExpression]);
            }
        }

        $handler->addMethodCall('push', [$headerExpression]);
        $handler->addMethodCall('push', [$logExpression]);
        // goes on the end of the stack.
        $handler->addMethodCall('unshift', [$eventExpression]);

        return $handler;
    }

    /**
     * Create Logger
     *
     * @since  2015-07
     *
     * @param  array            $config
     * @param  ContainerBuilder $container
     *
     * @return Definition
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     */
    protected function createLogger(array $config, ContainerBuilder $container)
    {

        if ($config['logging'] === true) {
            $logger = new Definition('%guzzle_bundle.logger.class%');
        } else {
            $logger = new Definition('EightPoints\Bundle\GuzzleBundle\Log\DevNullLogger');
        }

        $container->setDefinition('guzzle_bundle.logger', $logger);

        return $logger;
    }

    /**
     * Create Middleware for Logging
     *
     * @since  2015-07
     *
     * @return Definition
     */
    protected function createLogMiddleware()
    {
        $log = new Definition('%guzzle_bundle.middleware.log.class%');
        $log->addArgument(new Reference('guzzle_bundle.logger'));
        $log->addArgument(new Reference('guzzle_bundle.formatter'));

        return $log;
    }

    /**
     * Create Middleware For Request Headers
     *
     * @since  2015-07
     *
     * @param  array $headers
     *
     * @return Definition
     */
    protected function createRequestHeaderMiddleware(array $headers)
    {
        $requestHeader = new Definition('%guzzle_bundle.middleware.request_header.class%');
        $requestHeader->addArgument($this->cleanUpHeaders($headers));

        return $requestHeader;
    }

    /**
     * Create Middleware For dispatching events
     *
     * @since  2015-09
     *
     * @param  string $name
     *
     * @return Definition
     */
    protected function createEventMiddleware($name)
    {
        $eventMiddleWare = new Definition('%guzzle_bundle.middleware.event_dispatcher.class%');
        $eventMiddleWare->addArgument(new Reference('event_dispatcher'));
        $eventMiddleWare->addArgument($name);

        return $eventMiddleWare;
    }

    /**
     * Create Middleware for WSSE
     *
     * @since  2015-07
     *
     * @param  string  $username
     * @param  string  $password
     * @param  string  $createdAtExpression
     *
     * @return Definition
     */
    protected function createWsseMiddleware($username, $password, $createdAtExpression = null)
    {
        $wsse = new Definition('%guzzle_bundle.middleware.wsse.class%');
        $wsse->setArguments([$username, $password]);

        if ($createdAtExpression) {
            $wsse->addMethodCall('setCreatedAtTimeExpression', array($createdAtExpression));
        }

        return $wsse;
    }

    /**
     * Clean up HTTP headers
     *
     * @since  2015-07
     *
     * @param  array $headers
     *
     * @return array
     */
    protected function cleanUpHeaders(array $headers)
    {
        foreach ($headers as $name => $value) {

            // because of standard conventions in YAML dashes are converted to underscores
            // underscores are not allowed in HTTP standard, will be replaced by dash
            $nameClean = str_replace('_', '-', $name);

            unset($headers[$name]);

            $headers[$nameClean] = $value;
        }

        return $headers;
    }

    /**
     * Returns alias of extension
     *
     * @version 1.1
     * @since   2013-12
     *
     * @return  string
     */
    public function getAlias()
    {
        return 'guzzle';
    }
}


text:
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/disk.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/buf.h>
#include <sys/malloc.h>
#include <sys/devicestat.h>
#include <sys/sysctl.h>
#include <machine/stdarg.h>
#include <machine/resource.h>
#include <machine/bus.h>
#include <sys/rman.h>
#include <dev/ata/ata-all.h>

static int
ata_pccard_probe(device_t dev)
{
    struct ata_channel *ch = device_get_softc(dev);
    struct resource *io;
    int rid, len, start, end;
    u_long tmp;

    /* allocate the io range to get start and length */
    rid = ATA_IOADDR_RID;
    len = bus_get_resource_count(dev, SYS_RES_IOPORT, rid);
    io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
			    ATA_IOSIZE, RF_ACTIVE);
    if (!io)
	return ENOMEM;

    /* reallocate the io address to only cover the io ports */
    start = rman_get_start(io);
    end = start + ATA_IOSIZE - 1;
    bus_release_resource(dev, SYS_RES_IOPORT, rid, io);
    io = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
			    start, end, ATA_IOSIZE, RF_ACTIVE);
    bus_release_resource(dev, SYS_RES_IOPORT, rid, io);

    /*
     * if we got more than the default ATA_IOSIZE ports, this is likely
     * a pccard system where the altio ports are located at offset 14
     * otherwise its the normal altio offset
     */
    if (bus_get_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID, &tmp, &tmp)) {
	if (len > ATA_IOSIZE) {
	    bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID,
			     start + ATA_PCCARD_ALTOFFSET, ATA_ALTIOSIZE);
	}
	else {
	    bus_set_resource(dev, SYS_RES_IOPORT, ATA_ALTADDR_RID,
			     start + ATA_ALTOFFSET, ATA_ALTIOSIZE);
	}
    }
    else
	return ENOMEM;

    ch->unit = 0;
    ch->flags |= (ATA_USE_16BIT | ATA_NO_SLAVE);
    return ata_probe(dev);
}

static device_method_t ata_pccard_methods[] = {
    /* device interface */
    DEVMETHOD(device_probe,	ata_pccard_probe),
    DEVMETHOD(device_attach,	ata_attach),
    DEVMETHOD(device_detach,	ata_detach),
    { 0, 0 }
};

static driver_t ata_pccard_driver = {
    "ata",
    ata_pccard_methods,
    sizeof(struct ata_channel),
};

DRIVER_MODULE(ata, pccard, ata_pccard_driver, ata_devclass, 0, 0);

redpajama_set_name: RedPajamaGithub


text:
<?php

use yii\helpers\Html;
use yii\grid\GridView;

/* @var $this yii\web\View */
/* @var $searchModel app\models\UserScoreSearch */
/* @var $dataProvider yii\data\ActiveDataProvider */

$this->title = 'User Scores';
$this->params['breadcrumbs'][] = $this->title;
?>

    <?php // echo $this->render('_search', ['model' => $searchModel]); ?>

        <?= Html::a('Create User Score', ['create'], ['class' => 'btn btn-success']) ?>

    <?= GridView::widget([
        'dataProvider' => $dataProvider,
        'filterModel' => $searchModel,
        'columns' => [
            ['class' => 'yii\grid\SerialColumn'],

            'id',
            'user_id',
            'lesson_id',
            'exam_date',
            'score',
            // 'create_date',
            // 'update_date',

            ['class' => 'yii\grid\ActionColumn'],
        ],
    ]); ?>


text:
#ifndef _XTENSA_BOOTPARAM_H
#define _XTENSA_BOOTPARAM_H

#define BP_VERSION 0x0001

#define BP_TAG_COMMAND_LINE	0x1001	/* command line (0-terminated string)*/
#define BP_TAG_INITRD		0x1002	/* ramdisk addr and size (bp_meminfo) */
#define BP_TAG_MEMORY		0x1003	/* memory addr and size (bp_meminfo) */
#define BP_TAG_SERIAL_BAUSRATE	0x1004	/* baud rate of current console. */
#define BP_TAG_SERIAL_PORT	0x1005	/* serial device of current console */

#define BP_TAG_FIRST		0x7B0B  /* first tag with a version number */
#define BP_TAG_LAST 		0x7E0B	/* last tag */

#ifndef __ASSEMBLY__

/* All records are aligned to 4 bytes */

typedef struct bp_tag {
  unsigned short id;		/* tag id */
  unsigned short size;		/* size of this record excluding the structure*/
  unsigned long data[0];	/* data */
} bp_tag_t;

typedef struct meminfo {
  unsigned long type;
  unsigned long start;
  unsigned long end;
} meminfo_t;

#define SYSMEM_BANKS_MAX 5

#define MEMORY_TYPE_CONVENTIONAL	0x1000
#define MEMORY_TYPE_NONE		0x2000

typedef struct sysmem_info {
  int nr_banks;
  meminfo_t bank[SYSMEM_BANKS_MAX];
} sysmem_info_t;

extern sysmem_info_t sysmem;

#endif
#endif


text:
<?php

use Doctrine\ORM\Mapping\Driver\YamlDriver;
use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\Tools\Console\ConsoleRunner;
use Doctrine\ORM\EntityManager;

class DoctrineManager extends \Ezrun\Core\System\SystemAbstract {

    protected $config;
    protected $em;
    protected $driver;
    protected $helperSet;
    protected $cmf;

    public function prepareVariables() {

        $dbParams = array(
            'driver'   => db_driver,
            'user'     => db_user,
            'password' => db_pass,
            'dbname'   => db_name,
            'charset'  => db_charset,
        );

        $this->config = Setup::createAnnotationMetadataConfiguration(array(yaml_path), false);
        $this->em     = EntityManager::create($dbParams, $this->config);

        // custom datatypes (not mapped for reverse engineering)
        $this->em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string');
        $this->em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');

        $this->driver = new YamlDriver(array(yaml_path));

        $this->config->setMetadataDriverImpl($this->driver);

        $this->helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
            'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($this->em->getConnection()),
            'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($this->em)
        ));

        $this->cmf = new Doctrine\ORM\Tools\DisconnectedClassMetadataFactory();
        $this->cmf->setEntityManager($this->em);
    }

    public function executeCommand() {

        switch($this->getCommand()) {

            case 'orm:generate-entities':
                $this->generateEntities();
                break;
            case 'orm:schema-tool:create':
                $this->schemaCreate();
                break;
            case 'orm:schema-tool:update':
                $this->schemaUpdate();
                break;
            case 'orm:schema-tool:drop':
                $this->schemaDrop();
                break;
            default:
                echo 'Unknown command';
                break;
        }

        //ConsoleRunner::run($helperSet);
        //exec("" . vendor_path . "bin/doctrine {$this->getCommand()}", $output);
    }

    private function generateEntities() {

        $metadata = $this->cmf->getAllMetadata();

        $generator = new \Doctrine\ORM\Tools\EntityGenerator();
        $generator->setRegenerateEntityIfExists(true);
        $generator->setUpdateEntityIfExists(true);
        $generator->setGenerateStubMethods(true);
        $generator->setGenerateAnnotations(true);
        $generator->setBackupExisting(false);
        $generator->generate($metadata, entities_path);
    }

    private function schemaCreate() {

        $schema_tool    = new \Doctrine\ORM\Tools\SchemaTool($this->em);
        $metadata       = $this->cmf->getAllMetadata();

        return $schema_tool->createSchema($metadata);
    }

    private function schemaUpdate() {

        $schema_tool    = new \Doctrine\ORM\Tools\SchemaTool($this->em);
        $metadata       = $this->cmf->getAllMetadata();

        return $schema_tool->updateSchema($metadata);
    }

    private function schemaDrop() {

        $schema_tool    = new \Doctrine\ORM\Tools\SchemaTool($this->em);
        $metadata       = $this->cmf->getAllMetadata();

        $schema_tool->dropSchema($metadata);
    }
}


text:
(function(){
    $('.community').addClass('active');
})()


text:
{{ range $.Site.Data.case_studies.case_studies }}

{{ .sentence }}

{{ end }}


text:
package org.neptunepowered.vanilla.mixin.core.entity.player;

import net.canarymod.api.entity.living.humanoid.HumanCapabilities;
import net.minecraft.entity.player.PlayerCapabilities;
import org.spongepowered.asm.mixin.Implements;
import org.spongepowered.asm.mixin.Interface;
import org.spongepowered.asm.mixin.Intrinsic;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;

@Mixin(PlayerCapabilities.class)
@Implements(@Interface(iface = HumanCapabilities.class, prefix = "capabilities$"))
public abstract class MixinPlayerCapabilities implements HumanCapabilities {

    @Shadow public boolean disableDamage;
    @Shadow public boolean isFlying;
    @Shadow public boolean allowFlying;
    @Shadow public boolean isCreativeMode;
    @Shadow private float flySpeed;
    @Shadow private float walkSpeed;

    @Shadow public abstract float getFlySpeed();
    @Shadow public abstract float getWalkSpeed();

    @Override
    public boolean isInvulnerable() {
        return this.disableDamage;
    }

    @Override
    public void setInvulnerable(boolean invulnerable) {
        this.disableDamage = invulnerable;
    }

    @Override
    public boolean isFlying() {
        return this.isFlying;
    }

    @Override
    public void setFlying(boolean flying) {
        this.isFlying = flying;
    }

    @Override
    public boolean mayFly() {
        return this.allowFlying;
    }

    @Override
    public void setMayFly(boolean mayfly) {
        this.allowFlying = mayfly;
    }

    @Override
    public boolean instantBuild() {
        return this.isCreativeMode;
    }

    @Override
    public void setInstantBuild(boolean instant) {
        this.isCreativeMode = instant;
    }

    @Intrinsic
    public float capabilities$getFlySpeed() {
        return this.getFlySpeed();
    }

    @Override
    public void setFlySpeed(float speed) {
        this.flySpeed = speed;
    }

    @Intrinsic
    public float capabilities$getWalkSpeed() {
        return this.getWalkSpeed();
    }

    @Override
    public void setWalkSpeed(float speed) {
        this.walkSpeed = speed;
    }

}


text:
#include <config.h>

#if ! HAVE_INLINE
# define static_inline
#endif
#include "xalloc.h"
#undef static_inline

#include <stdlib.h>
#include <string.h>

/* 1 if calloc is known to be compatible with GNU calloc.  This
   matters if we are not also using the calloc module, which defines
   HAVE_CALLOC and supports the GNU API even on non-GNU platforms.  */
#if defined HAVE_CALLOC || defined __GLIBC__
enum { HAVE_GNU_CALLOC = 1 };
#else
enum { HAVE_GNU_CALLOC = 0 };
#endif

/* Allocate N bytes of memory dynamically, with error checking.  */

void *
xmalloc (size_t n)
{
  void *p = malloc (n);
  if (!p && n != 0)
    xalloc_die ();
  return p;
}

/* Change the size of an allocated block of memory P to N bytes,
   with error checking.  */

void *
xrealloc (void *p, size_t n)
{
  p = realloc (p, n);
  if (!p && n != 0)
    xalloc_die ();
  return p;
}

/* If P is null, allocate a block of at least *PN bytes; otherwise,
   reallocate P so that it contains more than *PN bytes.  *PN must be
   nonzero unless P is null.  Set *PN to the new block's size, and
   return the pointer to the new block.  *PN is never set to zero, and
   the returned pointer is never null.  */

void *
x2realloc (void *p, size_t *pn)
{
  return x2nrealloc (p, pn, 1);
}

/* Allocate S bytes of zeroed memory dynamically, with error checking.
   There's no need for xnzalloc (N, S), since it would be equivalent
   to xcalloc (N, S).  */

void *
xzalloc (size_t s)
{
  return memset (xmalloc (s), 0, s);
}

/* Allocate zeroed memory for N elements of S bytes, with error
   checking.  S must be nonzero.  */

void *
xcalloc (size_t n, size_t s)
{
  void *p;
  /* Test for overflow, since some calloc implementations don't have
     proper overflow checks.  But omit overflow and size-zero tests if
     HAVE_GNU_CALLOC, since GNU calloc catches overflow and never
     returns NULL if successful.  */
  if ((! HAVE_GNU_CALLOC && xalloc_oversized (n, s))
      || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))
    xalloc_die ();
  return p;
}

/* Clone an object P of size S, with error checking.  There's no need
   for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any
   need for an arithmetic overflow check.  */

void *
xmemdup (void const *p, size_t s)
{
  return memcpy (xmalloc (s), p, s);
}

/* Clone STRING.  */

char *
xstrdup (char const *string)
{
  return xmemdup (string, strlen (string) + 1);
}


text:
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, minimum-scale=1, initial-scale=1, user-scalable=yes">

    <title>todo-auth</title>

    <script src="../bower_components/webcomponentsjs/webcomponents-lite.js"></script>
    <script src="../bower_components/web-component-tester/browser.js"></script>

    <!-- Import the element to test -->
    <link rel="import" href="../src/todo-auth.html">
  </head>
  <body>
    <test-fixture id="basic">
      <template>
        <todo-auth></todo-auth>
      </template>
    </test-fixture>

    <script>
      suite('todo-auth tests', function() {
        var home;

        setup(function() {
          home = fixture('basic');
        });

        test('Number in circle should be 1', function() {
          var circle = Polymer.dom(home.root).querySelector('.circle');
          assert.equal(circle.textContent, '1');
        })
      });
    </script>
  </body>
</html>


text:
CREATE TABLE list (id VARCHAR(2) NOT NULL, value VARCHAR(64) NOT NULL, PRIMARY KEY(id));

INSERT INTO "list" ("id", "value") VALUES (E'af', E'afrikaani');
INSERT INTO "list" ("id", "value") VALUES (E'af_ZA', E'afrikaani (Lõuna-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'af_NA', E'afrikaani (Namiibia)');
INSERT INTO "list" ("id", "value") VALUES (E'ak', E'akani');
INSERT INTO "list" ("id", "value") VALUES (E'ak_GH', E'akani (Ghana)');
INSERT INTO "list" ("id", "value") VALUES (E'sq', E'albaania');
INSERT INTO "list" ("id", "value") VALUES (E'sq_AL', E'albaania (Albaania)');
INSERT INTO "list" ("id", "value") VALUES (E'sq_XK', E'albaania (Kosovo)');
INSERT INTO "list" ("id", "value") VALUES (E'sq_MK', E'albaania (Makedoonia)');
INSERT INTO "list" ("id", "value") VALUES (E'am', E'amhari');
INSERT INTO "list" ("id", "value") VALUES (E'am_ET', E'amhari (Etioopia)');
INSERT INTO "list" ("id", "value") VALUES (E'ar', E'araabia');
INSERT INTO "list" ("id", "value") VALUES (E'ar_DZ', E'araabia (Alžeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_AE', E'araabia (Araabia Ühendemiraadid)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_BH', E'araabia (Bahrein)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_DJ', E'araabia (Djibouti)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_EG', E'araabia (Egiptus)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_ER', E'araabia (Eritrea)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_IL', E'araabia (Iisrael)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_IQ', E'araabia (Iraak)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_YE', E'araabia (Jeemen)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_JO', E'araabia (Jordaania)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_QA', E'araabia (Katar)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_KM', E'araabia (Komoorid)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_KW', E'araabia (Kuveit)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_LB', E'araabia (Liibanon)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_LY', E'araabia (Liibüa)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_SS', E'araabia (Lõuna-Sudaan)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_EH', E'araabia (Lääne-Sahara)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_MA', E'araabia (Maroko)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_MR', E'araabia (Mauritaania)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_OM', E'araabia (Omaan)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_PS', E'araabia (Palestiina alad)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_SA', E'araabia (Saudi Araabia)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_SO', E'araabia (Somaalia)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_SD', E'araabia (Sudaan)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_SY', E'araabia (Süüria)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_TD', E'araabia (Tšaad)');
INSERT INTO "list" ("id", "value") VALUES (E'ar_TN', E'araabia (Tuneesia)');
INSERT INTO "list" ("id", "value") VALUES (E'hy', E'armeenia');
INSERT INTO "list" ("id", "value") VALUES (E'hy_AM', E'armeenia (Armeenia)');
INSERT INTO "list" ("id", "value") VALUES (E'az', E'aserbaidžaani');
INSERT INTO "list" ("id", "value") VALUES (E'az_AZ', E'aserbaidžaani (Aserbaidžaan)');
INSERT INTO "list" ("id", "value") VALUES (E'az_Cyrl_AZ', E'aserbaidžaani (kirillitsa, Aserbaidžaan)');
INSERT INTO "list" ("id", "value") VALUES (E'az_Cyrl', E'aserbaidžaani (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'az_Latn_AZ', E'aserbaidžaani (ladina, Aserbaidžaan)');
INSERT INTO "list" ("id", "value") VALUES (E'az_Latn', E'aserbaidžaani (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'as', E'assami');
INSERT INTO "list" ("id", "value") VALUES (E'as_IN', E'assami (India)');
INSERT INTO "list" ("id", "value") VALUES (E'bm', E'bambara');
INSERT INTO "list" ("id", "value") VALUES (E'bm_Latn_ML', E'bambara (ladina, Mali)');
INSERT INTO "list" ("id", "value") VALUES (E'bm_Latn', E'bambara (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'eu', E'baski');
INSERT INTO "list" ("id", "value") VALUES (E'eu_ES', E'baski (Hispaania)');
INSERT INTO "list" ("id", "value") VALUES (E'bn', E'bengali');
INSERT INTO "list" ("id", "value") VALUES (E'bn_BD', E'bengali (Bangladesh)');
INSERT INTO "list" ("id", "value") VALUES (E'bn_IN', E'bengali (India)');
INSERT INTO "list" ("id", "value") VALUES (E'my', E'birma');
INSERT INTO "list" ("id", "value") VALUES (E'my_MM', E'birma (Myanmar (Birma))');
INSERT INTO "list" ("id", "value") VALUES (E'bs', E'bosnia');
INSERT INTO "list" ("id", "value") VALUES (E'bs_BA', E'bosnia (Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'bs_Cyrl_BA', E'bosnia (kirillitsa, Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'bs_Cyrl', E'bosnia (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'bs_Latn_BA', E'bosnia (ladina, Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'bs_Latn', E'bosnia (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'br', E'bretooni');
INSERT INTO "list" ("id", "value") VALUES (E'br_FR', E'bretooni (Prantsusmaa)');
INSERT INTO "list" ("id", "value") VALUES (E'bg', E'bulgaaria');
INSERT INTO "list" ("id", "value") VALUES (E'bg_BG', E'bulgaaria (Bulgaaria)');
INSERT INTO "list" ("id", "value") VALUES (E'dz', E'dzongkha');
INSERT INTO "list" ("id", "value") VALUES (E'dz_BT', E'dzongkha (Bhutan)');
INSERT INTO "list" ("id", "value") VALUES (E'et', E'eesti');
INSERT INTO "list" ("id", "value") VALUES (E'et_EE', E'eesti (Eesti)');
INSERT INTO "list" ("id", "value") VALUES (E'eo', E'esperanto');
INSERT INTO "list" ("id", "value") VALUES (E'ee', E'eve');
INSERT INTO "list" ("id", "value") VALUES (E'ee_GH', E'eve (Ghana)');
INSERT INTO "list" ("id", "value") VALUES (E'ee_TG', E'eve (Togo)');
INSERT INTO "list" ("id", "value") VALUES (E'ff', E'fulbe');
INSERT INTO "list" ("id", "value") VALUES (E'ff_GN', E'fulbe (Guinea)');
INSERT INTO "list" ("id", "value") VALUES (E'ff_CM', E'fulbe (Kamerun)');
INSERT INTO "list" ("id", "value") VALUES (E'ff_MR', E'fulbe (Mauritaania)');
INSERT INTO "list" ("id", "value") VALUES (E'ff_SN', E'fulbe (Senegal)');
INSERT INTO "list" ("id", "value") VALUES (E'fo', E'fääri');
INSERT INTO "list" ("id", "value") VALUES (E'fo_FO', E'fääri (Fääri saared)');
INSERT INTO "list" ("id", "value") VALUES (E'gd', E'gaeli');
INSERT INTO "list" ("id", "value") VALUES (E'gd_GB', E'gaeli (Suurbritannia)');
INSERT INTO "list" ("id", "value") VALUES (E'gl', E'galeegi');
INSERT INTO "list" ("id", "value") VALUES (E'gl_ES', E'galeegi (Hispaania)');
INSERT INTO "list" ("id", "value") VALUES (E'lg', E'ganda');
INSERT INTO "list" ("id", "value") VALUES (E'lg_UG', E'ganda (Uganda)');
INSERT INTO "list" ("id", "value") VALUES (E'ka', E'gruusia');
INSERT INTO "list" ("id", "value") VALUES (E'ka_GE', E'gruusia (Gruusia)');
INSERT INTO "list" ("id", "value") VALUES (E'kl', E'grööni');
INSERT INTO "list" ("id", "value") VALUES (E'kl_GL', E'grööni (Gröönimaa)');
INSERT INTO "list" ("id", "value") VALUES (E'gu', E'gudžarati');
INSERT INTO "list" ("id", "value") VALUES (E'gu_IN', E'gudžarati (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ha', E'hausa');
INSERT INTO "list" ("id", "value") VALUES (E'ha_GH', E'hausa (Ghana)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_Latn_GH', E'hausa (ladina, Ghana)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_Latn_NG', E'hausa (ladina, Nigeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_Latn_NE', E'hausa (ladina, Niger)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_Latn', E'hausa (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_NG', E'hausa (Nigeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'ha_NE', E'hausa (Niger)');
INSERT INTO "list" ("id", "value") VALUES (E'he', E'heebrea');
INSERT INTO "list" ("id", "value") VALUES (E'he_IL', E'heebrea (Iisrael)');
INSERT INTO "list" ("id", "value") VALUES (E'zh', E'hiina');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hans_CN', E'hiina (hiina lihtsustatud, Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hans_HK', E'hiina (hiina lihtsustatud, Hongkong - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hans_MO', E'hiina (hiina lihtsustatud, Macau - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hans_SG', E'hiina (hiina lihtsustatud, Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hans', E'hiina (hiina lihtsustatud)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hant_HK', E'hiina (hiina traditsiooniline, Hongkong - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hant_MO', E'hiina (hiina traditsiooniline, Macau - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hant_TW', E'hiina (hiina traditsiooniline, Taiwan)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_Hant', E'hiina (hiina traditsiooniline)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_CN', E'hiina (Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_HK', E'hiina (Hongkong - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_MO', E'hiina (Macau - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_SG', E'hiina (Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'zh_TW', E'hiina (Taiwan)');
INSERT INTO "list" ("id", "value") VALUES (E'hi', E'hindi');
INSERT INTO "list" ("id", "value") VALUES (E'hi_IN', E'hindi (India)');
INSERT INTO "list" ("id", "value") VALUES (E'es', E'hispaania');
INSERT INTO "list" ("id", "value") VALUES (E'es_US', E'hispaania (Ameerika Ühendriigid)');
INSERT INTO "list" ("id", "value") VALUES (E'es_AR', E'hispaania (Argentina)');
INSERT INTO "list" ("id", "value") VALUES (E'es_BO', E'hispaania (Boliivia)');
INSERT INTO "list" ("id", "value") VALUES (E'es_EA', E'hispaania (Ceuta ja Melilla)');
INSERT INTO "list" ("id", "value") VALUES (E'es_CO', E'hispaania (Colombia)');
INSERT INTO "list" ("id", "value") VALUES (E'es_CR', E'hispaania (Costa Rica)');
INSERT INTO "list" ("id", "value") VALUES (E'es_DO', E'hispaania (Dominikaani Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'es_EC', E'hispaania (Ecuador)');
INSERT INTO "list" ("id", "value") VALUES (E'es_GQ', E'hispaania (Ekvatoriaal-Guinea)');
INSERT INTO "list" ("id", "value") VALUES (E'es_SV', E'hispaania (El Salvador)');
INSERT INTO "list" ("id", "value") VALUES (E'es_PH', E'hispaania (Filipiinid)');
INSERT INTO "list" ("id", "value") VALUES (E'es_GT', E'hispaania (Guatemala)');
INSERT INTO "list" ("id", "value") VALUES (E'es_ES', E'hispaania (Hispaania)');
INSERT INTO "list" ("id", "value") VALUES (E'es_HN', E'hispaania (Honduras)');
INSERT INTO "list" ("id", "value") VALUES (E'es_IC', E'hispaania (Kanaari saared)');
INSERT INTO "list" ("id", "value") VALUES (E'es_CU', E'hispaania (Kuuba)');
INSERT INTO "list" ("id", "value") VALUES (E'es_MX', E'hispaania (Mehhiko)');
INSERT INTO "list" ("id", "value") VALUES (E'es_NI', E'hispaania (Nicaragua)');
INSERT INTO "list" ("id", "value") VALUES (E'es_PA', E'hispaania (Panama)');
INSERT INTO "list" ("id", "value") VALUES (E'es_PY', E'hispaania (Paraguay)');
INSERT INTO "list" ("id", "value") VALUES (E'es_PE', E'hispaania (Peruu)');
INSERT INTO "list" ("id", "value") VALUES (E'es_PR', E'hispaania (Puerto Rico)');
INSERT INTO "list" ("id", "value") VALUES (E'es_CL', E'hispaania (Tšiili)');
INSERT INTO "list" ("id", "value") VALUES (E'es_UY', E'hispaania (Uruguay)');
INSERT INTO "list" ("id", "value") VALUES (E'es_VE', E'hispaania (Venezuela)');
INSERT INTO "list" ("id", "value") VALUES (E'nl', E'hollandi');
INSERT INTO "list" ("id", "value") VALUES (E'nl_AW', E'hollandi (Aruba)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_BE', E'hollandi (Belgia)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_CW', E'hollandi (Curaçao)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_NL', E'hollandi (Holland)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_BQ', E'hollandi (Hollandi Kariibi mere saared)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_SX', E'hollandi (Sint Maarten)');
INSERT INTO "list" ("id", "value") VALUES (E'nl_SR', E'hollandi (Suriname)');
INSERT INTO "list" ("id", "value") VALUES (E'hr', E'horvaadi');
INSERT INTO "list" ("id", "value") VALUES (E'hr_BA', E'horvaadi (Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'hr_HR', E'horvaadi (Horvaatia)');
INSERT INTO "list" ("id", "value") VALUES (E'ig', E'ibo');
INSERT INTO "list" ("id", "value") VALUES (E'ig_NG', E'ibo (Nigeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'ga', E'iiri');
INSERT INTO "list" ("id", "value") VALUES (E'ga_IE', E'iiri (Iirimaa)');
INSERT INTO "list" ("id", "value") VALUES (E'id', E'indoneesia');
INSERT INTO "list" ("id", "value") VALUES (E'id_ID', E'indoneesia (Indoneesia)');
INSERT INTO "list" ("id", "value") VALUES (E'en', E'inglise');
INSERT INTO "list" ("id", "value") VALUES (E'en_AS', E'inglise (Ameerika Samoa)');
INSERT INTO "list" ("id", "value") VALUES (E'en_US', E'inglise (Ameerika Ühendriigid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_AI', E'inglise (Anguilla)');
INSERT INTO "list" ("id", "value") VALUES (E'en_AG', E'inglise (Antigua ja Barbuda)');
INSERT INTO "list" ("id", "value") VALUES (E'en_AU', E'inglise (Austraalia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BS', E'inglise (Bahama)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BB', E'inglise (Barbados)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PW', E'inglise (Belau)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BE', E'inglise (Belgia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BZ', E'inglise (Belize)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BM', E'inglise (Bermuda)');
INSERT INTO "list" ("id", "value") VALUES (E'en_BW', E'inglise (Botswana)');
INSERT INTO "list" ("id", "value") VALUES (E'en_IO', E'inglise (Briti India ookeani ala)');
INSERT INTO "list" ("id", "value") VALUES (E'en_VG', E'inglise (Briti Neitsisaared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_CK', E'inglise (Cooki saared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_DG', E'inglise (Diego Garcia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_DM', E'inglise (Dominica)');
INSERT INTO "list" ("id", "value") VALUES (E'en_ER', E'inglise (Eritrea)');
INSERT INTO "list" ("id", "value") VALUES (E'en_FK', E'inglise (Falklandi saared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_FJ', E'inglise (Fidži)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PH', E'inglise (Filipiinid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GM', E'inglise (Gambia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GH', E'inglise (Ghana)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GI', E'inglise (Gibraltar)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GD', E'inglise (Grenada)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GU', E'inglise (Guam)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GG', E'inglise (Guernsey)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GY', E'inglise (Guyana)');
INSERT INTO "list" ("id", "value") VALUES (E'en_HK', E'inglise (Hongkong - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'en_IE', E'inglise (Iirimaa)');
INSERT INTO "list" ("id", "value") VALUES (E'en_IN', E'inglise (India)');
INSERT INTO "list" ("id", "value") VALUES (E'en_JM', E'inglise (Jamaica)');
INSERT INTO "list" ("id", "value") VALUES (E'en_JE', E'inglise (Jersey)');
INSERT INTO "list" ("id", "value") VALUES (E'en_CX', E'inglise (Jõulusaar)');
INSERT INTO "list" ("id", "value") VALUES (E'en_KY', E'inglise (Kaimanisaared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_CM', E'inglise (Kamerun)');
INSERT INTO "list" ("id", "value") VALUES (E'en_CA', E'inglise (Kanada)');
INSERT INTO "list" ("id", "value") VALUES (E'en_KE', E'inglise (Kenya)');
INSERT INTO "list" ("id", "value") VALUES (E'en_KI', E'inglise (Kiribati)');
INSERT INTO "list" ("id", "value") VALUES (E'en_CC', E'inglise (Kookossaared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_LS', E'inglise (Lesotho)');
INSERT INTO "list" ("id", "value") VALUES (E'en_LR', E'inglise (Libeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'en_ZA', E'inglise (Lõuna-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SS', E'inglise (Lõuna-Sudaan)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MO', E'inglise (Macau - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MG', E'inglise (Madagaskar)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MY', E'inglise (Malaisia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MW', E'inglise (Malawi)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MT', E'inglise (Malta)');
INSERT INTO "list" ("id", "value") VALUES (E'en_IM', E'inglise (Mani saar)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MH', E'inglise (Marshalli saared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MU', E'inglise (Mauritius)');
INSERT INTO "list" ("id", "value") VALUES (E'en_FM', E'inglise (Mikroneesia Liiduriigid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MS', E'inglise (Montserrat)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NA', E'inglise (Namiibia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NR', E'inglise (Nauru)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NG', E'inglise (Nigeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NU', E'inglise (Niue)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NF', E'inglise (Norfolk)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PG', E'inglise (Paapua Uus-Guinea)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PK', E'inglise (Pakistan)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PN', E'inglise (Pitcairni saared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_PR', E'inglise (Puerto Rico)');
INSERT INTO "list" ("id", "value") VALUES (E'en_MP', E'inglise (Põhja-Mariaanid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_RW', E'inglise (Rwanda)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SB', E'inglise (Saalomoni Saared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SH', E'inglise (Saint Helena)');
INSERT INTO "list" ("id", "value") VALUES (E'en_KN', E'inglise (Saint Kitts ja Nevis)');
INSERT INTO "list" ("id", "value") VALUES (E'en_LC', E'inglise (Saint Lucia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_VC', E'inglise (Saint Vincent ja Grenadiinid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_ZM', E'inglise (Sambia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_WS', E'inglise (Samoa)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SC', E'inglise (Seišellid)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SL', E'inglise (Sierra Leone)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SG', E'inglise (Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SX', E'inglise (Sint Maarten)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SD', E'inglise (Sudaan)');
INSERT INTO "list" ("id", "value") VALUES (E'en_GB', E'inglise (Suurbritannia)');
INSERT INTO "list" ("id", "value") VALUES (E'en_SZ', E'inglise (Svaasimaa)');
INSERT INTO "list" ("id", "value") VALUES (E'en_ZW', E'inglise (Zimbabwe)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TZ', E'inglise (Tansaania)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TK', E'inglise (Tokelau)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TO', E'inglise (Tonga)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TT', E'inglise (Trinidad ja Tobago)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TC', E'inglise (Turks ja Caicos)');
INSERT INTO "list" ("id", "value") VALUES (E'en_TV', E'inglise (Tuvalu)');
INSERT INTO "list" ("id", "value") VALUES (E'en_UG', E'inglise (Uganda)');
INSERT INTO "list" ("id", "value") VALUES (E'en_VI', E'inglise (USA Neitsisaared)');
INSERT INTO "list" ("id", "value") VALUES (E'en_NZ', E'inglise (Uus-Meremaa)');
INSERT INTO "list" ("id", "value") VALUES (E'en_VU', E'inglise (Vanuatu)');
INSERT INTO "list" ("id", "value") VALUES (E'en_UM', E'inglise (Ühendriikide hajasaared)');
INSERT INTO "list" ("id", "value") VALUES (E'is', E'islandi');
INSERT INTO "list" ("id", "value") VALUES (E'is_IS', E'islandi (Island)');
INSERT INTO "list" ("id", "value") VALUES (E'it', E'itaalia');
INSERT INTO "list" ("id", "value") VALUES (E'it_IT', E'itaalia (Itaalia)');
INSERT INTO "list" ("id", "value") VALUES (E'it_SM', E'itaalia (San Marino)');
INSERT INTO "list" ("id", "value") VALUES (E'it_CH', E'itaalia (Šveits)');
INSERT INTO "list" ("id", "value") VALUES (E'ja', E'jaapani');
INSERT INTO "list" ("id", "value") VALUES (E'ja_JP', E'jaapani (Jaapan)');
INSERT INTO "list" ("id", "value") VALUES (E'yi', E'jidiši');
INSERT INTO "list" ("id", "value") VALUES (E'yo', E'joruba');
INSERT INTO "list" ("id", "value") VALUES (E'yo_BJ', E'joruba (Benin)');
INSERT INTO "list" ("id", "value") VALUES (E'yo_NG', E'joruba (Nigeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'kn', E'kannada');
INSERT INTO "list" ("id", "value") VALUES (E'kn_IN', E'kannada (India)');
INSERT INTO "list" ("id", "value") VALUES (E'kk', E'kasahhi');
INSERT INTO "list" ("id", "value") VALUES (E'kk_KZ', E'kasahhi (Kasahstan)');
INSERT INTO "list" ("id", "value") VALUES (E'kk_Cyrl_KZ', E'kasahhi (kirillitsa, Kasahstan)');
INSERT INTO "list" ("id", "value") VALUES (E'kk_Cyrl', E'kasahhi (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'ks', E'kašmiiri');
INSERT INTO "list" ("id", "value") VALUES (E'ks_Arab_IN', E'kašmiiri (araabia, India)');
INSERT INTO "list" ("id", "value") VALUES (E'ks_Arab', E'kašmiiri (araabia)');
INSERT INTO "list" ("id", "value") VALUES (E'ks_IN', E'kašmiiri (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ca', E'katalaani');
INSERT INTO "list" ("id", "value") VALUES (E'ca_AD', E'katalaani (Andorra)');
INSERT INTO "list" ("id", "value") VALUES (E'ca_ES', E'katalaani (Hispaania)');
INSERT INTO "list" ("id", "value") VALUES (E'ca_IT', E'katalaani (Itaalia)');
INSERT INTO "list" ("id", "value") VALUES (E'ca_FR', E'katalaani (Prantsusmaa)');
INSERT INTO "list" ("id", "value") VALUES (E'qu', E'ketšua');
INSERT INTO "list" ("id", "value") VALUES (E'qu_BO', E'ketšua (Boliivia)');
INSERT INTO "list" ("id", "value") VALUES (E'qu_EC', E'ketšua (Ecuador)');
INSERT INTO "list" ("id", "value") VALUES (E'qu_PE', E'ketšua (Peruu)');
INSERT INTO "list" ("id", "value") VALUES (E'km', E'khmeeri');
INSERT INTO "list" ("id", "value") VALUES (E'km_KH', E'khmeeri (Kambodža)');
INSERT INTO "list" ("id", "value") VALUES (E'ki', E'kikuju');
INSERT INTO "list" ("id", "value") VALUES (E'ki_KE', E'kikuju (Kenya)');
INSERT INTO "list" ("id", "value") VALUES (E'ky', E'kirgiisi');
INSERT INTO "list" ("id", "value") VALUES (E'ky_Cyrl_KG', E'kirgiisi (kirillitsa, Kõrgõzstan)');
INSERT INTO "list" ("id", "value") VALUES (E'ky_Cyrl', E'kirgiisi (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'ky_KG', E'kirgiisi (Kõrgõzstan)');
INSERT INTO "list" ("id", "value") VALUES (E'ko', E'korea');
INSERT INTO "list" ("id", "value") VALUES (E'ko_KR', E'korea (Lõuna-Korea)');
INSERT INTO "list" ("id", "value") VALUES (E'ko_KP', E'korea (Põhja-Korea)');
INSERT INTO "list" ("id", "value") VALUES (E'kw', E'korni');
INSERT INTO "list" ("id", "value") VALUES (E'kw_GB', E'korni (Suurbritannia)');
INSERT INTO "list" ("id", "value") VALUES (E'el', E'kreeka');
INSERT INTO "list" ("id", "value") VALUES (E'el_GR', E'kreeka (Kreeka)');
INSERT INTO "list" ("id", "value") VALUES (E'el_CY', E'kreeka (Küpros)');
INSERT INTO "list" ("id", "value") VALUES (E'cy', E'kõmri');
INSERT INTO "list" ("id", "value") VALUES (E'cy_GB', E'kõmri (Suurbritannia)');
INSERT INTO "list" ("id", "value") VALUES (E'lo', E'lao');
INSERT INTO "list" ("id", "value") VALUES (E'lo_LA', E'lao (Laos)');
INSERT INTO "list" ("id", "value") VALUES (E'lt', E'leedu');
INSERT INTO "list" ("id", "value") VALUES (E'lt_LT', E'leedu (Leedu)');
INSERT INTO "list" ("id", "value") VALUES (E'lb', E'letseburgi');
INSERT INTO "list" ("id", "value") VALUES (E'lb_LU', E'letseburgi (Luksemburg)');
INSERT INTO "list" ("id", "value") VALUES (E'ln', E'lingala');
INSERT INTO "list" ("id", "value") VALUES (E'ln_AO', E'lingala (Angola)');
INSERT INTO "list" ("id", "value") VALUES (E'ln_CF', E'lingala (Kesk-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'ln_CD', E'lingala (Kongo DV)');
INSERT INTO "list" ("id", "value") VALUES (E'ln_CG', E'lingala (Kongo-Brazzaville)');
INSERT INTO "list" ("id", "value") VALUES (E'lu', E'luba');
INSERT INTO "list" ("id", "value") VALUES (E'lu_CD', E'luba (Kongo DV)');
INSERT INTO "list" ("id", "value") VALUES (E'lv', E'läti');
INSERT INTO "list" ("id", "value") VALUES (E'lv_LV', E'läti (Läti)');
INSERT INTO "list" ("id", "value") VALUES (E'fy', E'läänefriisi');
INSERT INTO "list" ("id", "value") VALUES (E'fy_NL', E'läänefriisi (Holland)');
INSERT INTO "list" ("id", "value") VALUES (E'mk', E'makedoonia');
INSERT INTO "list" ("id", "value") VALUES (E'mk_MK', E'makedoonia (Makedoonia)');
INSERT INTO "list" ("id", "value") VALUES (E'mg', E'malagassi');
INSERT INTO "list" ("id", "value") VALUES (E'mg_MG', E'malagassi (Madagaskar)');
INSERT INTO "list" ("id", "value") VALUES (E'ms', E'malai');
INSERT INTO "list" ("id", "value") VALUES (E'ms_BN', E'malai (Brunei)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_Latn_BN', E'malai (ladina, Brunei)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_Latn_MY', E'malai (ladina, Malaisia)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_Latn_SG', E'malai (ladina, Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_Latn', E'malai (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_MY', E'malai (Malaisia)');
INSERT INTO "list" ("id", "value") VALUES (E'ms_SG', E'malai (Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'ml', E'malajalami');
INSERT INTO "list" ("id", "value") VALUES (E'ml_IN', E'malajalami (India)');
INSERT INTO "list" ("id", "value") VALUES (E'mt', E'malta');
INSERT INTO "list" ("id", "value") VALUES (E'mt_MT', E'malta (Malta)');
INSERT INTO "list" ("id", "value") VALUES (E'mr', E'marathi');
INSERT INTO "list" ("id", "value") VALUES (E'mr_IN', E'marathi (India)');
INSERT INTO "list" ("id", "value") VALUES (E'mn', E'mongoli');
INSERT INTO "list" ("id", "value") VALUES (E'mn_Cyrl_MN', E'mongoli (kirillitsa, Mongoolia)');
INSERT INTO "list" ("id", "value") VALUES (E'mn_Cyrl', E'mongoli (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'mn_MN', E'mongoli (Mongoolia)');
INSERT INTO "list" ("id", "value") VALUES (E'gv', E'mänksi');
INSERT INTO "list" ("id", "value") VALUES (E'gv_IM', E'mänksi (Mani saar)');
INSERT INTO "list" ("id", "value") VALUES (E'ne', E'nepali');
INSERT INTO "list" ("id", "value") VALUES (E'ne_IN', E'nepali (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ne_NP', E'nepali (Nepal)');
INSERT INTO "list" ("id", "value") VALUES (E'no', E'norra');
INSERT INTO "list" ("id", "value") VALUES (E'no_NO', E'norra (Norra)');
INSERT INTO "list" ("id", "value") VALUES (E'nb', E'norra bokmål');
INSERT INTO "list" ("id", "value") VALUES (E'nb_NO', E'norra bokmål (Norra)');
INSERT INTO "list" ("id", "value") VALUES (E'nb_SJ', E'norra bokmål (Svalbard ja Jan Mayen)');
INSERT INTO "list" ("id", "value") VALUES (E'nn', E'norra nynorsk');
INSERT INTO "list" ("id", "value") VALUES (E'nn_NO', E'norra nynorsk (Norra)');
INSERT INTO "list" ("id", "value") VALUES (E'or', E'oria');
INSERT INTO "list" ("id", "value") VALUES (E'or_IN', E'oria (India)');
INSERT INTO "list" ("id", "value") VALUES (E'om', E'oromo');
INSERT INTO "list" ("id", "value") VALUES (E'om_ET', E'oromo (Etioopia)');
INSERT INTO "list" ("id", "value") VALUES (E'om_KE', E'oromo (Kenya)');
INSERT INTO "list" ("id", "value") VALUES (E'os', E'osseedi');
INSERT INTO "list" ("id", "value") VALUES (E'os_GE', E'osseedi (Gruusia)');
INSERT INTO "list" ("id", "value") VALUES (E'os_RU', E'osseedi (Venemaa)');
INSERT INTO "list" ("id", "value") VALUES (E'pa', E'pandžabi');
INSERT INTO "list" ("id", "value") VALUES (E'pa_Arab_PK', E'pandžabi (araabia, Pakistan)');
INSERT INTO "list" ("id", "value") VALUES (E'pa_Arab', E'pandžabi (araabia)');
INSERT INTO "list" ("id", "value") VALUES (E'pa_Guru_IN', E'pandžabi (gurmukhi, India)');
INSERT INTO "list" ("id", "value") VALUES (E'pa_Guru', E'pandžabi (gurmukhi)');
INSERT INTO "list" ("id", "value") VALUES (E'pa_IN', E'pandžabi (India)');
INSERT INTO "list" ("id", "value") VALUES (E'pa_PK', E'pandžabi (Pakistan)');
INSERT INTO "list" ("id", "value") VALUES (E'pl', E'poola');
INSERT INTO "list" ("id", "value") VALUES (E'pl_PL', E'poola (Poola)');
INSERT INTO "list" ("id", "value") VALUES (E'pt', E'portugali');
INSERT INTO "list" ("id", "value") VALUES (E'pt_AO', E'portugali (Angola)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_BR', E'portugali (Brasiilia)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_GW', E'portugali (Guinea-Bissau)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_TL', E'portugali (Ida-Timor)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_MO', E'portugali (Macau - Hiina erihalduspiirkond)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_MZ', E'portugali (Mosambiik)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_PT', E'portugali (Portugal)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_CV', E'portugali (Roheneemesaared)');
INSERT INTO "list" ("id", "value") VALUES (E'pt_ST', E'portugali (São Tomé ja Príncipe)');
INSERT INTO "list" ("id", "value") VALUES (E'fr', E'prantsuse');
INSERT INTO "list" ("id", "value") VALUES (E'fr_DZ', E'prantsuse (Alžeeria)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_BE', E'prantsuse (Belgia)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_BJ', E'prantsuse (Benin)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_BF', E'prantsuse (Burkina Faso)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_BI', E'prantsuse (Burundi)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CI', E'prantsuse (Côte d'Ivoire)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_DJ', E'prantsuse (Djibouti)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_GQ', E'prantsuse (Ekvatoriaal-Guinea)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_GA', E'prantsuse (Gabon)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_GP', E'prantsuse (Guadeloupe)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_GN', E'prantsuse (Guinea)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_HT', E'prantsuse (Haiti)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CM', E'prantsuse (Kamerun)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CA', E'prantsuse (Kanada)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CF', E'prantsuse (Kesk-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_KM', E'prantsuse (Komoorid)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CD', E'prantsuse (Kongo DV)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CG', E'prantsuse (Kongo-Brazzaville)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_LU', E'prantsuse (Luksemburg)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MG', E'prantsuse (Madagaskar)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_ML', E'prantsuse (Mali)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MA', E'prantsuse (Maroko)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MQ', E'prantsuse (Martinique)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MR', E'prantsuse (Mauritaania)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MU', E'prantsuse (Mauritius)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_YT', E'prantsuse (Mayotte)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MC', E'prantsuse (Monaco)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_NE', E'prantsuse (Niger)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_GF', E'prantsuse (Prantsuse Guajaana)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_PF', E'prantsuse (Prantsuse Polüneesia)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_FR', E'prantsuse (Prantsusmaa)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_RE', E'prantsuse (Réunion)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_RW', E'prantsuse (Rwanda)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_BL', E'prantsuse (Saint Barthélemy)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_MF', E'prantsuse (Saint Martin)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_PM', E'prantsuse (Saint Pierre ja Miquelon)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_SC', E'prantsuse (Seišellid)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_SN', E'prantsuse (Senegal)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_SY', E'prantsuse (Süüria)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_CH', E'prantsuse (Šveits)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_TG', E'prantsuse (Togo)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_TD', E'prantsuse (Tšaad)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_TN', E'prantsuse (Tuneesia)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_NC', E'prantsuse (Uus-Kaledoonia)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_VU', E'prantsuse (Vanuatu)');
INSERT INTO "list" ("id", "value") VALUES (E'fr_WF', E'prantsuse (Wallis ja Futuna)');
INSERT INTO "list" ("id", "value") VALUES (E'ps', E'puštu');
INSERT INTO "list" ("id", "value") VALUES (E'ps_AF', E'puštu (Afganistan)');
INSERT INTO "list" ("id", "value") VALUES (E'nd', E'põhjandebele');
INSERT INTO "list" ("id", "value") VALUES (E'nd_ZW', E'põhjandebele (Zimbabwe)');
INSERT INTO "list" ("id", "value") VALUES (E'se', E'põhjasaami');
INSERT INTO "list" ("id", "value") VALUES (E'se_NO', E'põhjasaami (Norra)');
INSERT INTO "list" ("id", "value") VALUES (E'se_SE', E'põhjasaami (Rootsi)');
INSERT INTO "list" ("id", "value") VALUES (E'se_FI', E'põhjasaami (Soome)');
INSERT INTO "list" ("id", "value") VALUES (E'fa', E'pärsia');
INSERT INTO "list" ("id", "value") VALUES (E'fa_AF', E'pärsia (Afganistan)');
INSERT INTO "list" ("id", "value") VALUES (E'fa_IR', E'pärsia (Iraan)');
INSERT INTO "list" ("id", "value") VALUES (E'rm', E'retoromaani');
INSERT INTO "list" ("id", "value") VALUES (E'rm_CH', E'retoromaani (Šveits)');
INSERT INTO "list" ("id", "value") VALUES (E'sv', E'rootsi');
INSERT INTO "list" ("id", "value") VALUES (E'sv_AX', E'rootsi (Ahvenamaa)');
INSERT INTO "list" ("id", "value") VALUES (E'sv_SE', E'rootsi (Rootsi)');
INSERT INTO "list" ("id", "value") VALUES (E'sv_FI', E'rootsi (Soome)');
INSERT INTO "list" ("id", "value") VALUES (E'rw', E'ruanda');
INSERT INTO "list" ("id", "value") VALUES (E'rw_RW', E'ruanda (Rwanda)');
INSERT INTO "list" ("id", "value") VALUES (E'ro', E'rumeenia');
INSERT INTO "list" ("id", "value") VALUES (E'ro_MD', E'rumeenia (Moldova)');
INSERT INTO "list" ("id", "value") VALUES (E'ro_RO', E'rumeenia (Rumeenia)');
INSERT INTO "list" ("id", "value") VALUES (E'rn', E'rundi');
INSERT INTO "list" ("id", "value") VALUES (E'rn_BI', E'rundi (Burundi)');
INSERT INTO "list" ("id", "value") VALUES (E'de', E'saksa');
INSERT INTO "list" ("id", "value") VALUES (E'de_AT', E'saksa (Austria)');
INSERT INTO "list" ("id", "value") VALUES (E'de_BE', E'saksa (Belgia)');
INSERT INTO "list" ("id", "value") VALUES (E'de_LI', E'saksa (Liechtenstein)');
INSERT INTO "list" ("id", "value") VALUES (E'de_LU', E'saksa (Luksemburg)');
INSERT INTO "list" ("id", "value") VALUES (E'de_DE', E'saksa (Saksamaa)');
INSERT INTO "list" ("id", "value") VALUES (E'de_CH', E'saksa (Šveits)');
INSERT INTO "list" ("id", "value") VALUES (E'sg', E'sango');
INSERT INTO "list" ("id", "value") VALUES (E'sg_CF', E'sango (Kesk-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'sr', E'serbia');
INSERT INTO "list" ("id", "value") VALUES (E'sr_BA', E'serbia (Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Cyrl_BA', E'serbia (kirillitsa, Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Cyrl_XK', E'serbia (kirillitsa, Kosovo)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Cyrl_ME', E'serbia (kirillitsa, Montenegro)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Cyrl_RS', E'serbia (kirillitsa, Serbia)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Cyrl', E'serbia (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_XK', E'serbia (Kosovo)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Latn_BA', E'serbia (ladina, Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Latn_XK', E'serbia (ladina, Kosovo)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Latn_ME', E'serbia (ladina, Montenegro)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Latn_RS', E'serbia (ladina, Serbia)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_Latn', E'serbia (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_ME', E'serbia (Montenegro)');
INSERT INTO "list" ("id", "value") VALUES (E'sr_RS', E'serbia (Serbia)');
INSERT INTO "list" ("id", "value") VALUES (E'sh', E'serbia-horvaadi');
INSERT INTO "list" ("id", "value") VALUES (E'sh_BA', E'serbia-horvaadi (Bosnia ja Hertsegoviina)');
INSERT INTO "list" ("id", "value") VALUES (E'ii', E'sichuani jii');
INSERT INTO "list" ("id", "value") VALUES (E'ii_CN', E'sichuani jii (Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'si', E'singali');
INSERT INTO "list" ("id", "value") VALUES (E'si_LK', E'singali (Sri Lanka)');
INSERT INTO "list" ("id", "value") VALUES (E'sk', E'slovaki');
INSERT INTO "list" ("id", "value") VALUES (E'sk_SK', E'slovaki (Slovakkia)');
INSERT INTO "list" ("id", "value") VALUES (E'sl', E'sloveeni');
INSERT INTO "list" ("id", "value") VALUES (E'sl_SI', E'sloveeni (Sloveenia)');
INSERT INTO "list" ("id", "value") VALUES (E'so', E'somaali');
INSERT INTO "list" ("id", "value") VALUES (E'so_DJ', E'somaali (Djibouti)');
INSERT INTO "list" ("id", "value") VALUES (E'so_ET', E'somaali (Etioopia)');
INSERT INTO "list" ("id", "value") VALUES (E'so_KE', E'somaali (Kenya)');
INSERT INTO "list" ("id", "value") VALUES (E'so_SO', E'somaali (Somaalia)');
INSERT INTO "list" ("id", "value") VALUES (E'fi', E'soome');
INSERT INTO "list" ("id", "value") VALUES (E'fi_FI', E'soome (Soome)');
INSERT INTO "list" ("id", "value") VALUES (E'sw', E'suahiili');
INSERT INTO "list" ("id", "value") VALUES (E'sw_KE', E'suahiili (Kenya)');
INSERT INTO "list" ("id", "value") VALUES (E'sw_TZ', E'suahiili (Tansaania)');
INSERT INTO "list" ("id", "value") VALUES (E'sw_UG', E'suahiili (Uganda)');
INSERT INTO "list" ("id", "value") VALUES (E'zu', E'suulu');
INSERT INTO "list" ("id", "value") VALUES (E'zu_ZA', E'suulu (Lõuna-Aafrika Vabariik)');
INSERT INTO "list" ("id", "value") VALUES (E'sn', E'šona');
INSERT INTO "list" ("id", "value") VALUES (E'sn_ZW', E'šona (Zimbabwe)');
INSERT INTO "list" ("id", "value") VALUES (E'da', E'taani');
INSERT INTO "list" ("id", "value") VALUES (E'da_GL', E'taani (Gröönimaa)');
INSERT INTO "list" ("id", "value") VALUES (E'da_DK', E'taani (Taani)');
INSERT INTO "list" ("id", "value") VALUES (E'tl', E'tagalogi');
INSERT INTO "list" ("id", "value") VALUES (E'tl_PH', E'tagalogi (Filipiinid)');
INSERT INTO "list" ("id", "value") VALUES (E'th', E'tai');
INSERT INTO "list" ("id", "value") VALUES (E'th_TH', E'tai (Tai)');
INSERT INTO "list" ("id", "value") VALUES (E'ta', E'tamili');
INSERT INTO "list" ("id", "value") VALUES (E'ta_IN', E'tamili (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ta_MY', E'tamili (Malaisia)');
INSERT INTO "list" ("id", "value") VALUES (E'ta_SG', E'tamili (Singapur)');
INSERT INTO "list" ("id", "value") VALUES (E'ta_LK', E'tamili (Sri Lanka)');
INSERT INTO "list" ("id", "value") VALUES (E'te', E'telugu');
INSERT INTO "list" ("id", "value") VALUES (E'te_IN', E'telugu (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ti', E'tigrinja');
INSERT INTO "list" ("id", "value") VALUES (E'ti_ER', E'tigrinja (Eritrea)');
INSERT INTO "list" ("id", "value") VALUES (E'ti_ET', E'tigrinja (Etioopia)');
INSERT INTO "list" ("id", "value") VALUES (E'bo', E'tiibeti');
INSERT INTO "list" ("id", "value") VALUES (E'bo_CN', E'tiibeti (Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'bo_IN', E'tiibeti (India)');
INSERT INTO "list" ("id", "value") VALUES (E'to', E'tonga');
INSERT INTO "list" ("id", "value") VALUES (E'to_TO', E'tonga (Tonga)');
INSERT INTO "list" ("id", "value") VALUES (E'cs', E'tšehhi');
INSERT INTO "list" ("id", "value") VALUES (E'cs_CZ', E'tšehhi (Tšehhi)');
INSERT INTO "list" ("id", "value") VALUES (E'tr', E'türgi');
INSERT INTO "list" ("id", "value") VALUES (E'tr_CY', E'türgi (Küpros)');
INSERT INTO "list" ("id", "value") VALUES (E'tr_TR', E'türgi (Türgi)');
INSERT INTO "list" ("id", "value") VALUES (E'ug', E'uiguuri');
INSERT INTO "list" ("id", "value") VALUES (E'ug_Arab_CN', E'uiguuri (araabia, Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'ug_Arab', E'uiguuri (araabia)');
INSERT INTO "list" ("id", "value") VALUES (E'ug_CN', E'uiguuri (Hiina)');
INSERT INTO "list" ("id", "value") VALUES (E'uk', E'ukraina');
INSERT INTO "list" ("id", "value") VALUES (E'uk_UA', E'ukraina (Ukraina)');
INSERT INTO "list" ("id", "value") VALUES (E'hu', E'ungari');
INSERT INTO "list" ("id", "value") VALUES (E'hu_HU', E'ungari (Ungari)');
INSERT INTO "list" ("id", "value") VALUES (E'ur', E'urdu');
INSERT INTO "list" ("id", "value") VALUES (E'ur_IN', E'urdu (India)');
INSERT INTO "list" ("id", "value") VALUES (E'ur_PK', E'urdu (Pakistan)');
INSERT INTO "list" ("id", "value") VALUES (E'uz', E'usbeki');
INSERT INTO "list" ("id", "value") VALUES (E'uz_AF', E'usbeki (Afganistan)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Arab_AF', E'usbeki (araabia, Afganistan)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Arab', E'usbeki (araabia)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Cyrl_UZ', E'usbeki (kirillitsa, Usbekistan)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Cyrl', E'usbeki (kirillitsa)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Latn_UZ', E'usbeki (ladina, Usbekistan)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_Latn', E'usbeki (ladina)');
INSERT INTO "list" ("id", "value") VALUES (E'uz_UZ', E'usbeki (Usbekistan)');
INSERT INTO "list" ("id", "value") VALUES (E'be', E'valgevene');
INSERT INTO "list" ("id", "value") VALUES (E'be_BY', E'valgevene (Valgevene)');
INSERT INTO "list" ("id", "value") VALUES (E'ru', E'vene');
INSERT INTO "list" ("id", "value") VALUES (E'ru_KZ', E'vene (Kasahstan)');
INSERT INTO "list" ("id", "value") VALUES (E'ru_KG', E'vene (Kõrgõzstan)');
INSERT INTO "list" ("id", "value") VALUES (E'ru_MD', E'vene (Moldova)');
INSERT INTO "list" ("id", "value") VALUES (E'ru_UA', E'vene (Ukraina)');
INSERT INTO "list" ("id", "value") VALUES (E'ru_BY', E'vene (Valgevene)');
INSERT INTO "list" ("id", "value") VALUES (E'ru_RU', E'vene (Venemaa)');
INSERT INTO "list" ("id", "value") VALUES (E'vi', E'vietnami');
INSERT INTO "list" ("id", "value") VALUES (E'vi_VN', E'vietnami (Vietnam)');


text:
package org.uberfire.provisioning.local.runtime.provider;

import static java.util.UUID.randomUUID;
import org.uberfire.provisioning.exceptions.ProvisioningException;
import org.uberfire.provisioning.runtime.RuntimeConfiguration;
import org.uberfire.provisioning.runtime.providers.ProviderService;

public class LocalProviderService implements ProviderService {

    private LocalProvider provider;

    public LocalProviderService( LocalProvider provider ) {
        this.provider = provider;
    }

    @Override
    public org.uberfire.provisioning.runtime.Runtime create( RuntimeConfiguration runtimeConfig ) throws ProvisioningException {
        String shortId = randomUUID().toString().substring( 0, 12 );
        return new LocalRuntime( shortId, runtimeConfig, provider );

    }

    @Override
    public boolean destroy( String runtimeId ) throws ProvisioningException {
        return true;
    }
}


text:
"""
facilities.py
~~~~~~~~~~~~

This module implements settings HP OneView REST API
"""
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
from future import standard_library
standard_library.install_aliases()

__title__ = 'facilities'
__version__ = '0.0.1'
__copyright__ = '(C) Copyright 2012-2015 Hewlett-Packard Development ' \
                ' Development LP'
__license__ = 'MIT'
__status__ = 'Development'

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

from hpOneView.common import *
from hpOneView.connection import *
from hpOneView.activity import *
from hpOneView.exceptions import *

class facilities(object):

    def __init__(self, con):
        self._con = con
        self._activity = activity(con)

    def get_datacenters(self):
        body = self._con.get(uri['datacenters'])
        return body

    def get_powerdevices(self):
        body = self._con.get(uri['powerDevices'])
        return body

    def get_racks(self):
        body = self._con.get(uri['racks'])
        return body

    def delete_datacenter(self, datacenter, force=False, blocking=True,
                          verbose=False):
        if force:
            task, body = self._con.delete(datacenter['uri'] + '?force=True')
        else:
            task, body = self._con.delete(datacenter['uri'])
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
        return task

    def delete_rack(self, rack, force=False, blocking=True,
                          verbose=False):
        if force:
            task, body = self._con.delete(rack['uri'] + '?force=True')
        else:
            task, body = self._con.delete(rack['uri'])
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
        return task

    def delete_powerdevice(self, powerdevice, force=False, blocking=True,
                          verbose=False):
        if force:
            task, body = self._con.delete(powerdevice['uri'] + '?force=True')
        else:
            task, body = self._con.delete(powerdevice['uri'])
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
        return task

    def add_datacenter(self, datacenter, blocking=True, verbose=False):
        task, body = self._con.post(uri['datacenters'], datacenter)
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
            if task:
                if 'type' in task and task['type'].startswith('Task'):
                    entity = self._activity.get_task_associated_resource(task)
                    datacenter = self._con.get(entity['resourceUri'])
                    return datacenter
            return body
        return task

    def add_rack(self, rack, blocking=True, verbose=False):
        task, body = self._con.post(uri['racks'], rack)
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
            if task:
                if 'type' in task and task['type'].startswith('Task'):
                    entity = self._activity.get_task_associated_resource(task)
                    rack = self._con.get(entity['resourceUri'])
                    return rack
            return body
        return task

    def add_powerdevice(self, powerdevice, blocking=True, verbose=False):
        task, body = self._con.post(uri['powerDevices'], powerdevice)
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
            if task:
                if 'type' in task and task['type'].startswith('Task'):
                    entity = self._activity.get_task_associated_resource(task)
                    powerdevice = self._con.get(entity['resourceUri'])
                    return powerdevice
            return body
        return task

    def add_iPDU(self, host, user, passwd, blocking=True, verbose=False):
        request = {'hostname': host,
                   'username': user,
                   'password': passwd}
        task, body = self._con.post(uri['powerDevicesDiscover'], request)
        if blocking is True:
            task = self._activity.wait4task(task, tout=600, verbose=verbose)
            if task:
                if 'type' in task and task['type'].startswith('Task'):
                    entity = self._activity.get_task_associated_resource(task)
                    powerdevice = self._con.get(entity['resourceUri'])
                    return powerdevice
            return body
        return task

# vim:set shiftwidth=4 tabstop=4 expandtab textwidth=79:


text:
from __future__ import absolute_import

from django.http import HttpRequest, HttpResponse
from django.utils.translation import ugettext as _

from zerver.models import get_client
from zerver.lib.actions import check_send_message
from zerver.lib.response import json_success, json_error
from zerver.decorator import REQ, has_request_variables, authenticated_rest_api_view
from zerver.models import UserProfile
import ujson

from six import text_type
from typing import Any, Dict

@authenticated_rest_api_view(is_webhook=True)
@has_request_variables
def api_stash_webhook(request, user_profile, payload=REQ(argument_type='body'),
                      stream=REQ(default='commits')):
    # type: (HttpRequest, UserProfile, Dict[str, Any], text_type) -> HttpResponse
    # We don't get who did the push, or we'd try to report that.
    try:
        repo_name = payload["repository"]["name"]
        project_name = payload["repository"]["project"]["name"]
        branch_name = payload["refChanges"][0]["refId"].split("/")[-1]
        commit_entries = payload["changesets"]["values"]
        commits = [(entry["toCommit"]["displayId"],
                    entry["toCommit"]["message"].split("\n")[0]) for
                   entry in commit_entries]
        head_ref = commit_entries[-1]["toCommit"]["displayId"]
    except KeyError as e:
        return json_error(_("Missing key %s in JSON") % (str(e),))

    subject = "%s/%s: %s" % (project_name, repo_name, branch_name)

    content = "`%s` was pushed to **%s** in **%s/%s** with:\n\n" % (
        head_ref, branch_name, project_name, repo_name)
    content += "\n".join("* `%s`: %s" % (
            commit[0], commit[1]) for commit in commits)

    check_send_message(user_profile, get_client("ZulipStashWebhook"), "stream",
                       [stream], subject, content)
    return json_success()


text:
var cookie = require('cookie');
var parse = require('./lib/parse');

/**
 * Parse _Cookie_ header and populate `req.cookies`
 * with an object keyed by the cookie names. Optionally
 * you may enabled signed cookie support by passing
 * a `secret` string, which assigns `req.secret` so
 * it may be used by other middleware.
 *
 * Examples:
 *
 *     connect()
 *       .use(connect.cookieParser('optional secret string'))
 *       .use(function(req, res, next){
 *         res.end(JSON.stringify(req.cookies));
 *       })
 *
 * @param {String} secret
 * @return {Function}
 * @api public
 */

module.exports = function cookieParser(secret, opt){
  return function cookieParser(req, res, next) {
    if (req.cookies) return next();
    var cookies = req.headers.cookie;

    req.secret = secret;
    req.cookies = {};
    req.signedCookies = {};

    if (cookies) {
      try {
        req.cookies = cookie.parse(cookies, opt);
        if (secret) {
          req.signedCookies = parse.signedCookies(req.cookies, secret);
          req.signedCookies = parse.JSONCookies(req.signedCookies);
        }
        req.cookies = parse.JSONCookies(req.cookies);
      } catch (err) {
        err.status = 400;
        return next(err);
      }
    }
    next();
  };
};


text:
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Exchange = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';
'use babel';

var _sbEventKit = require('sb-event-kit');

var _sbCommunication = require('sb-communication');

var _sbCommunication2 = _interopRequireDefault(_sbCommunication);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Exchange {
  constructor(worker) {
    var _this = this;

    this.worker = worker;
    this.port = worker.port || worker;

    this.communication = new _sbCommunication2.default();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

    this.subscriptions.add(this.communication);

    const callback = function (message) {
      _this.communication.parseMessage(message.data);
    };
    this.port.addEventListener('message', callback);
    this.subscriptions.add(new _sbEventKit.Disposable(function () {
      _this.port.removeEventListener('message', callback);
    }));
    this.communication.onShouldSend(function (message) {
      _this.port.postMessage(message);
    });

    this.onRequest('ping', function (_, message) {
      message.response = 'pong';
    });
    this.request('ping');
  }

  request(name) {
    let data = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    return this.communication.request(name, data);
  }

  onRequest(name, callback) {
    return this.communication.onRequest(name, callback);
  }

  terminate() {
    if (this.worker.terminate) {
      this.worker.terminate();
    } else {
      this.port.close();
    }
    this.dispose();
  }
  dispose() {
    this.subscriptions.dispose();
  }

  static create(filePath) {
    return new Exchange(new Worker(filePath));
  }
  static createShared(filePath) {
    const worker = new SharedWorker(filePath);
    const exchange = new Exchange(worker);
    worker.port.start();
    return exchange;
  }
}

module.exports = Exchange;
},{"sb-communication":5,"sb-event-kit":9}],2:[function(require,module,exports){
'use strict';
'use babel';

var _sbEventKit = require('sb-event-kit');

var _sbCommunication = require('sb-communication');

var _sbCommunication2 = _interopRequireDefault(_sbCommunication);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class ExchangePort {
  constructor(port) {
    var _this = this;

    this.active = true;
    this.port = port;

    // Property initialization
    this.communication = new _sbCommunication2.default();
    this.emitter = new _sbEventKit.Emitter();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

    this.subscriptions.add(this.communication, this.emitter);

    // Share data between communication and port
    const callback = function (message) {
      _this.communication.parseMessage(message.data);
    };
    this.port.addEventListener('message', callback);
    this.subscriptions.add(new _sbEventKit.Disposable(function () {
      _this.port.removeEventListener('message', callback);
    }));
    this.communication.onShouldSend(function (message) {
      _this.port.postMessage(message);
    });

    // Check if the port is closed, we got no official close event
    let timeout;
    const ping = function () {
      if (!_this.active) {
        // Ignore if already disposed
        return;
      }
      _this.request('ping').then(function () {
        clearTimeout(timeout);
        setTimeout(ping, 1000);
      });
      timeout = setTimeout(function () {
        _this.dispose();
      }, 1000);
    };
    ping();

    this.onRequest('ping', function (_, message) {
      message.response = 'pong';
    });
  }

  request(name) {
    let data = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    if (!this.active) {
      throw new Error('Worker port has been disposed');
    }

    return this.communication.request(name, data);
  }

  onRequest(name, callback) {
    return this.communication.onRequest(name, callback);
  }

  onDidClose(callback) {
    return this.emitter.on('close', callback);
  }

  dispose() {
    if (this.active) {
      this.port.close();
      this.emitter.emit('close');
      this.active = false;
      this.subscriptions.dispose();
    }
  }
}

module.exports = ExchangePort;
},{"sb-communication":5,"sb-event-kit":9}],3:[function(require,module,exports){
'use strict';
'use babel';

var _sbEventKit = require('sb-event-kit');

var _exchangeWorkerPort = require('./exchange-worker-port');

var _exchangeWorkerPort2 = _interopRequireDefault(_exchangeWorkerPort);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

class Exchange {
  constructor() {
    this.ports = new Set();
    this.emitter = new _sbEventKit.Emitter();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

    this.subscriptions.add(this.emitter);
  }

  addPort(port) {
    var _this = this;

    const exchangePort = new _exchangeWorkerPort2.default(port);
    this.ports.add(exchangePort);
    this.subscriptions.add(exchangePort);
    exchangePort.onDidClose(function () {
      _this.ports.delete(exchangePort);
      _this.subscriptions.remove(exchangePort);
      _this.emitter.emit('port-close', exchangePort);
    });
    this.emitter.emit('port-add', exchangePort);
  }

  forEach(callback) {
    this.ports.forEach(callback);
  }
  observe(callback) {
    this.forEach(callback);
    return this.onDidPortAdd(callback);
  }
  onRequest(name, callback) {
    const subscriptions = new _sbEventKit.CompositeDisposable();
    subscriptions.add(this.observe(function (port) {
      subscriptions.add(port.onRequest(name, callback));
    }));
    return subscriptions;
  }
  onDidPortAdd(callback) {
    return this.emitter.on('port-add', callback);
  }
  onDidPortClose(callback) {
    return this.emitter.on('port-close', callback);
  }

  dispose() {
    this.subscriptions.dispose();
  }
}

module.exports = Exchange;
},{"./exchange-worker-port":2,"sb-event-kit":9}],4:[function(require,module,exports){
'use strict'

if (typeof document === 'undefined') {
  // We're in a worker
  const Exchange = require('./exchange-worker')
  const exchange = new Exchange()
  self.addEventListener('message', function Once(){
    // I am a dedicated worker
    exchange.addPort(self)
    self.removeEventListener('message', Once)
  })
  self.addEventListener('connect', function(e){
    // I am a shared worker
    const port = e.ports[0]
    exchange.addPort(port)
    port.start()
  })
  module.exports = Exchange
  self.exchange = exchange
} else {
  // We're in a host
  module.exports = require('./exchange-main')
}

},{"./exchange-main":1,"./exchange-worker":3}],5:[function(require,module,exports){
'use strict';
'use babel';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _sbEventKit = require('sb-event-kit');

class Communication {
  constructor(debug) {
    var _this = this;

    this.debug = Boolean(debug);
    this.emitter = new _sbEventKit.Emitter();
    this.subscriptions = new _sbEventKit.CompositeDisposable();

    this.emitter.on('request', function (message) {
      message.response = null;

      const response = new Promise(function (resolve) {
        _this.emitter.emit(`request:${ message.name }`, message.data, message);
        resolve(message.response);
      });

      response.then(function (response) {
        message.response = response;
        return true;
      }, function (val) {
        if (val instanceof Error) {
          const error = { __sb_is_error: true };
          Object.getOwnPropertyNames(val).forEach(function (key) {
            error[key] = val[key];
          });
          message.response = error;
        } else message.response = val;
        return false;
      }).then(function (status) {
        _this.emitter.emit('send', {
          id: message.id, sb_communication: true, status: status, type: 'response', data: message.response
        });
      });
    });
    this.emitter.on('response', function (message) {
      message.data = message.data && message.data.__sb_is_error ? Communication.createError(message.data) : message.data;
      _this.emitter.emit(`job:${ message.id }`, message);
    });
  }
  parseMessage(messageGiven) {
    let message;
    try {
      message = typeof messageGiven === 'string' ? JSON.parse(messageGiven) : messageGiven;
    } catch (_) {
      throw new Error('Error decoding response');
    }
    if (!message.sb_communication) {
      // Ignore unknown messages
      return;
    }
    if (this.debug) {
      console.debug(message);
    }
    this.emitter.emit(message.type, message);
  }
  request(name) {
    var _this2 = this;

    let data = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    return new Promise(function (resolve, reject) {
      const id = Communication.randomId();
      const disposable = _this2.emitter.on(`job:${ id }`, function (result) {
        disposable.dispose();
        if (result.status) {
          resolve(result.data);
        } else reject(result.data);
      });
      _this2.emitter.emit('send', {
        id: id, sb_communication: true, name: name, type: 'request', data: data
      });
    });
  }
  onRequest(name, callback) {
    return this.emitter.on(`request:${ name }`, callback);
  }
  onShouldSend(callback) {
    return this.emitter.on('send', callback);
  }
  dispose() {
    this.subscriptions.dispose();
    this.emitter.dispose();
  }
  static randomId() {
    return (Math.random().toString(36) + '00000000000000000').slice(2, 7 + 2);
  }
  static createError(data) {
    const error = new Error();
    for (const key in data) {
      if (key !== '__sb_is_error') {
        error[key] = data[key];
      }
    }
    return error;
  }
}
exports.default = Communication;
},{"sb-event-kit":9}],6:[function(require,module,exports){
'use strict';
'use babel';

Object.defineProperty(exports, "__esModule", {
  value: true
});
class CompositeDisposable {
  constructor() {
    this.disposed = false;
    this.disposables = new Set(arguments);
  }
  dispose() {
    if (!this.disposed) {
      this.disposed = true;
      this.disposables.forEach(function (item) {
        item.dispose();
      });
      this.disposables = null;
    }
  }
  add() {
    var _this = this;

    if (!this.disposed) {
      Array.prototype.forEach.call(arguments, function (item) {
        return _this.disposables.add(item);
      });
    }
  }
  remove() {
    var _this2 = this;

    if (!this.disposed) {
      Array.prototype.forEach.call(arguments, function (item) {
        return _this2.disposables.delete(item);
      });
    }
  }
  clear() {
    if (!this.disposed) {
      this.disposables.clear();
    }
  }
}
exports.CompositeDisposable = CompositeDisposable;
},{}],7:[function(require,module,exports){
'use strict';
'use babel';

Object.defineProperty(exports, "__esModule", {
  value: true
});
class Disposable {
  constructor(callback) {
    this.disposed = false;
    this.callback = callback;
  }
  dispose() {
    if (!this.disposed) {
      this.disposed = true;
      if (typeof this.callback === 'function') {
        this.callback();
      }
      this.callback = null;
    }
  }
}
exports.Disposable = Disposable;
},{}],8:[function(require,module,exports){
'use strict';
'use babel';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Emitter = undefined;

var _disposable = require('./disposable');

class Emitter {
  constructor() {
    this.disposed = false;
    this.handlers = {};
  }
  dispose() {
    this.disposed = true;
    this.handlers = null;
  }
  on(eventName, handler) {
    var _this = this;

    if (this.disposed) {
      throw new Error('Emitter has been disposed');
    }
    if (typeof handler !== 'function') {
      throw new Error('Event handler must be a function');
    }
    if (typeof this.handlers[eventName] === 'undefined') {
      this.handlers[eventName] = [handler];
    } else {
      this.handlers[eventName].push(handler);
    }
    return new _disposable.Disposable(function () {
      _this.off(eventName, handler);
    });
  }
  off(eventName, handler) {
    if (this.disposed || typeof this.handlers[eventName] === 'undefined') {
      return;
    }
    const index = this.handlers[eventName].indexOf(handler);
    if (index !== -1) {
      this.handlers[eventName].splice(index, 1);
    }
  }
  clear() {
    this.handlers = [];
  }
  emit(eventName) {
    for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      params[_key - 1] = arguments[_key];
    }

    if (this.disposed || typeof this.handlers[eventName] === 'undefined') {
      return;
    }
    const paramsLength = params.length;
    this.handlers[eventName].forEach(function (callback) {
      if (paramsLength === 1) {
        callback(params[0]);
      } else if (paramsLength === 2) {
        callback(params[0], params[1]);
      } else {
        callback.apply(undefined, params);
      }
    });
  }
}
exports.Emitter = Emitter;
},{"./disposable":7}],9:[function(require,module,exports){
'use strict';
'use babel';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _disposable = require('./disposable');

Object.defineProperty(exports, 'Disposable', {
  enumerable: true,
  get: function () {
    return _disposable.Disposable;
  }
});

var _compositeDisposable = require('./composite-disposable');

Object.defineProperty(exports, 'CompositeDisposable', {
  enumerable: true,
  get: function () {
    return _compositeDisposable.CompositeDisposable;
  }
});

var _emitter = require('./emitter');

Object.defineProperty(exports, 'Emitter', {
  enumerable: true,
  get: function () {
    return _emitter.Emitter;
  }
});
},{"./composite-disposable":6,"./disposable":7,"./emitter":8}]},{},[4])(4)
});


text:
        <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
          Toggle navigation

        </button>
        Get'er Done!

Boards (current)

            User Profile

Sign In

Sign Up

Log Out

Create an Account

        <form role="form" ng-submit="member.createMember()">

            Username
            <input id="name" type="name" ng-model="member.formData.name" placeholder="Enter username" name="name" class="form-control"/>

            Password
            <input id="password" type="password" ng-model="member.formData.password" placeholder="Password" name="password" class="form-control"/>

            Email
            <input id="email" type="email" ng-model="member.formData.email" placeholder="Email" name="email" class="form-control"/>
            <button id="info-submit" class="btn btn-default">Submit</button>

        </form>


text:
<?php

declare(strict_types=1);

namespace Core\Application\RealTime\UseCase\FindHost;

use Core\Application\Common\UseCase\PresenterInterface;

interface FindHostPresenterInterface extends PresenterInterface
{
    /**
     * {@inheritDoc}
     * @param FindHostResponse $response
     */
    public function present(mixed $response): void;
}


text:
title: Using Crate And Node.js For Data Enrichment
link: https://crate.io/blog/using-crate-and-node-js-for-data-enrichment/
author: Jodok Batlogg
description: Great post by Stefan Thies about how he used Crate and Node.js to overlay the raw data from website log files with whois information, enabling him to "name" visitors to a site.
created: 2014/08/05 11:24:25
post_name: using-crate-and-node-js-for-data-enrichment
status: publish
post_type: post
tags: nodejs, data enrichment, stefan thies
category: news, developernews

Great post by Stefan Thies about how he used Crate and Node.js to overlay the raw data from website log files with whois information, enabling him to "name" visitors to a site.

Data enrichment - overlaying data or the addition of metadata - is a known technique that can support anything from the use case in Stefan's post (assiging a "face" to site visitors) to fraud detection and security applications. It is definitely worth a read.

Click [here](http://techblog.bigdata-analyst.de/2014/08/04/data-enrichment-for-webanalytics-using-crate-data-and-node-js-to-overlay-data-in-one-day/) to read it.


text:
// $Id$

/** @file   testAliHLTGlobalBarrelTrack.C
    @author Matthias Richter
    @date   2010-12-17
    @brief  Test macro/program for the AliHLTGlobalBarrelTrack
 */

#ifndef __CINT__
#include <ostream>
#include <vector>
#include "AliHLTGlobalBarrelTrack.h"
#include "AliExternalTrackParam.h"
#include "TDatime.h"
#include "TRandom.h"
#endif //__CINT__

/**
 * Get a random number in the given range.
 */
int GetRandom(int min, int max)
{
  if (max-min<2) return min;
  static TRandom rand;
  static bool seedSet=false;
  if (!seedSet) {
    TDatime dt;
    rand.SetSeed(dt.Get());
    seedSet=true;
  }
  return min+rand.Integer(max-min);
}

int testAliHLTGlobalBarrelTrack()
{
  // test the AliHLTGlobalBarrelTrack class

  // 1)
  // the 5 track parameters are named in the AliHLTExternalTrackParam
  // while AliExternalTrackParam just uses an array[5]
  // the members have the same order, fY is the first one
  AliHLTExternalTrackParam hltparam;
  memset(&hltparam, 0, sizeof(AliHLTExternalTrackParam));
  hltparam.fY=GetRandom(0, 100000);
  hltparam.fZ=GetRandom(0, 100000);
  hltparam.fSinPsi=GetRandom(0, 100000);
  hltparam.fTgl=GetRandom(0, 100000);
  hltparam.fq1Pt=GetRandom(0, 100000);

  AliHLTGlobalBarrelTrack t(hltparam);
  if (TMath::Abs(hltparam.fY-t.GetY())>=1 ||
      TMath::Abs(hltparam.fZ-t.GetZ())>=1 ||
      TMath::Abs(hltparam.fSinPsi-t.GetSnp())>=1 ||
      TMath::Abs(hltparam.fTgl-t.GetTgl())>=1 ||
      TMath::Abs(hltparam.fq1Pt-t.GetSigned1Pt())) {
	cerr << "parameter sequence of AliExternalTrackParam and AliHLTExternalTrackParam does not match" << endl;
	return -1;
      }

  return 0;
}

int main(int /*argc*/, const char** /*argv*/)
{
  int iResult=0;
  if ((iResult=testAliHLTGlobalBarrelTrack())<0) {
  }
  return iResult;
}


text:
using System;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;

namespace Baku.KinectForPepper
{
    /// TCP/IP通信を用いて角度値を送信するコネクタを表します。
    public class AngleDataSender : IDisposable
    {
        /// 送信すべき角度値の要素数です。
        public const int JointNumber = RobotJointAngles.JointNumberToUse;
        /// 送信データが角度値であることを接続先に知らせるためのヘッダー文字列を表します。
        public const string SendAngleDataHeader = "setj";
        /// 接続先からの応答に対して予測される最大の文字列長です。
        public const int ReceiveDataBufferSize = 1024;

        /// 通信のうちテキストの表現に用いるエンコードです。
        private static readonly Encoding ConnectionEncoding = Encoding.ASCII;

        private bool _isConnected;
        /// TcpClientが接続中かどうかを表示します。
        public bool IsConnected
        {
            get { return _isConnected; }
            private set
            {
                if (_isConnected != value)
                {
                    _isConnected = value;
                    IsConnectedChanged?.Invoke(this, new IsConnectedChangedEventArgs(IsConnected));
                }
            }
        }

        /// 接続先との接続を試みます。
        public void Connect(string ip, int port)
        {
            if(!IsConnected)
            {
                try
                {
                    _client = new TcpClient();
                    _endPoint = new IPEndPoint(IPAddress.Parse(ip), port);
                    _client.Connect(_endPoint);
                    IsConnected = true;
                }
                catch(FormatException ex)
                {
                    Dispose();
                    FailedToConnect?.Invoke(this, new ExceptionMessageEventArgs(ex.Message));
                }
                catch (SocketException ex)
                {
                    Dispose();
                    FailedToConnect?.Invoke(this, new ExceptionMessageEventArgs(ex.Message));
                }
            }
        }

        /// 接続を遮断します。
        public void Close()
        {
            if(_client != null)
            {
                if (_client.Connected) _client.Close();
                _client = null;
            }
            IsConnected = false;
        }

        /// 接続を遮断します。
        public void Dispose()
        {
            Close();
        }

        /// 角度値を接続先へ送信します。接続先が無い場合は何もしません。
        /// <param name="angles">送信する角度値の一覧</param>
        public void SendAngleData(float[] angles)
        {
            if (!IsConnected) return;
            if (angles.Length != JointNumber)
            {
                throw new InvalidOperationException(
                    $"'angles.Length': {JointNumber} expected, but actual value was {angles.Length}"
                    );
            }

            try
            {
                var sendBuffer = new byte[angles.Length * 4 + 4];
                //代入操作を表すヘッダを設定
                byte[] setjHeader = ConnectionEncoding.GetBytes(SendAngleDataHeader);
                Array.Copy(setjHeader, 0, sendBuffer, 0, setjHeader.Length);

                //角度値を順に代入
                for (int i = 0; i < angles.Length; i++)
                {
                    byte[] f = BitConverter.GetBytes(angles[i]);
                    Array.Copy(f, 0, sendBuffer, i * 4 + 4, 4);
                }

                var stream = _client.GetStream();
                stream.Write(sendBuffer, 0, sendBuffer.Length);

                var receiveBuffer = new byte[ReceiveDataBufferSize];
                int resLen = stream.Read(receiveBuffer, 0, receiveBuffer.Length);

                string response = ConnectionEncoding.GetString(receiveBuffer, 0, resLen);

                DataSendCompleted?.Invoke(this, new DataSendCompletedEventArgs(response));
            }
            catch(IOException ex)
            {
                //サーバ側が急に落ちたケースを想定
                Dispose();
                ConnectionDisabled?.Invoke(this, new ExceptionMessageEventArgs(ex.Message));
            }
        }

        public string Address => (_endPoint != null && IsConnected) ? _endPoint.Address.ToString() : String.Empty;
        public int Port => (_endPoint != null && IsConnected) ? _endPoint.Port : -1;

        public event EventHandler<IsConnectedChangedEventArgs> IsConnectedChanged;
        public event EventHandler<DataSendCompletedEventArgs> DataSendCompleted;

        /// 接続操作に失敗すると発火します。
        public event EventHandler<ExceptionMessageEventArgs> FailedToConnect;
        /// 接続中にサーバ側から切断されると発火します。
        public event EventHandler<ExceptionMessageEventArgs> ConnectionDisabled;

        private TcpClient _client;
        private IPEndPoint _endPoint;

    }

    public class IsConnectedChangedEventArgs : EventArgs
    {
        public IsConnectedChangedEventArgs(bool isConnected)
        {
            IsConnected = isConnected;
        }
        public bool IsConnected { get; }
    }

    public class DataSendCompletedEventArgs : EventArgs
    {
        public DataSendCompletedEventArgs(string response)
        {
            Response = response;
        }
        public string Response { get; }
    }

    public class ExceptionMessageEventArgs : EventArgs
    {
        public ExceptionMessageEventArgs(string message)
        {
            Message = message;
        }
        public string Message { get; }
    }
}