text:
Kwf.Component.ClearCache = Ext.extend(Ext.Panel, {
    bodyStyle: 'padding: 50px;',
    initComponent: function() {
        Kwf.Component.ClearCache.superclass.initComponent.call(this);
    },
    afterRender: function() {
        Kwf.Component.ClearCache.superclass.afterRender.apply(this, arguments);
        this.body.createChild({
            style: 'font-size: 12px; margin-bottom: 20px;',
            html: '
Manually Clear Cache
It should not be necessary to clear the cache manually, you can still do it here'
        });

        this.body.createChild({
            style: 'font-size: 12px',
            html: 'Content changed in the CMS isn\'t shown on the website'
        });

        this.formPanel = new Ext.FormPanel({
            renderTo: this.body,
            baseCls: 'x-plain',
            labelWidth: 180,
            items: [new Ext.form.FieldSet({
                title: 'Filter',
                autoHeight: true,
                width: 400,
                items: [
                    {
                        style: 'font-size: 12px; ',
                        html: 'Use % as placeholder',
                        border: false
                    },
                    new Ext.form.TextField({
                        fieldLabel: 'component_id',
                        name: 'id'
                    }),
                    new Ext.form.TextField({
                        fieldLabel: 'db_id',
                        name: 'dbId'
                    }),
                    new Ext.form.TextField({
                        fieldLabel: 'expanded_component_id',
                        name: 'expandedId'
                    }),
                    new Ext.form.TextField({
                        fieldLabel: 'type',
                        name: 'type'
                    }),
                    new Ext.form.TextField({
                        fieldLabel: 'component_class',
                        name: 'class'
                    })
                ]
            })]
        });

        new Ext.Button({
            text: 'Clear View Cache',
            icon: '/assets/silkicons/page_white_text.png',
            cls: 'x-btn-text-icon',
            renderTo: this.body,
            style: 'margin-bottom: 20px',
            scope: this,
            handler: function() {
                Ext.Ajax.request({
                    url: this.controllerUrl+'/json-clear-view-cache',
                    params: this.formPanel.getForm().getValues(),
                    mask: true,
                    maskText: trlKwf('clearing cache...'),
                    success: function(response, options, r) {
                        Ext.Msg.show({
                            title:trlKwf('Clear Cache'),
                            msg: 'This will clear '+r.entries+' view cache entries. Continue?',
                            buttons: Ext.Msg.OKCANCEL,
                            scope: this,
                            fn: function(button) {
                                if (button == 'ok') {
                                    var params = this.formPanel.getForm().getValues();
                                    params.force = true;
                                    Ext.Ajax.request({
                                        url: this.controllerUrl+'/json-clear-view-cache',
                                        params: params,
                                        mask: true,
                                        maskText: trlKwf('clearing cache...')
                                    });
                                }
                            }});

                    },
                    scope: this
                });
            }
        });

        this.body.createChild({
            style: 'font-size: 12px',
            html: 'Changed translations aren\'t updated'
        });
        new Ext.Button({
            text: 'Clear Trl Cache',
            icon: '/assets/silkicons/application_view_columns.png',
            cls: 'x-btn-text-icon',
            renderTo: this.body,
            style: 'margin-bottom: 20px',
            scope: this,
            handler: function() {
                Ext.Ajax.request({
                    url: this.controllerUrl+'/json-clear-cache',
                    params: { type: 'trl' },
                    mask: true,
                    maskText: trlKwf('clearing cache...')
                });
            }
        });

        this.body.createChild({
            style: 'font-size: 12px',
            html: 'Images or other uploads aren\'t updated or shown in the wrong dimension'
        });
        new Ext.Button({
            text: 'Clear Media Cache',
            icon: '/assets/silkicons/image.png',
            cls: 'x-btn-text-icon',
            renderTo: this.body,
            style: 'margin-bottom: 20px',
            scope: this,
            handler: function() {
                Ext.Ajax.request({
                    url: this.controllerUrl+'/json-clear-cache',
                    params: { type: 'media' },
                    mask: true,
                    maskText: trlKwf('clearing cache...')
                });
            }
        });

        this.body.createChild({
            style: 'font-size: 12px',
            html: 'A Css or JavaScript file got changed but the change isn\'t visible'
        });
        new Ext.Button({
            text: 'Clear Assets Cache',
            icon: '/assets/silkicons/script_code.png',
            cls: 'x-btn-text-icon',
            renderTo: this.body,
            style: 'margin-bottom: 20px',
            scope: this,
            handler: function() {
                Ext.Ajax.request({
                    url: this.controllerUrl+'/json-clear-cache',
                    params: { type: 'assets' },
                    mask: true,
                    maskText: trlKwf('clearing cache...')
                });
            }
        });
        new Kwf.Auto.FormPanel({
            title: 'Yep, it was a cache issue, inform developers',
            border: true,
            controllerUrl: this.controllerUrl,
            renderTo: this.body
        });
    }
});
Ext.reg('kwf.component.clearCache', Kwf.Component.ClearCache);


text:
gridList
========

El pluging gridList permite mediante jQuery la carga de un grid de imágenes para usar en catálogos.

redpajama_set_name: RedPajamaGithub


text:
"""
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

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

"""
import os

from resource_management import Script, StackFeature
from resource_management.libraries.functions import get_kinit_path
from resource_management.libraries.functions import format
from resource_management.libraries.functions.default import default
from resource_management.libraries.functions import conf_select
from resource_management.libraries.functions import stack_select
from resource_management.libraries.functions.stack_features import check_stack_feature, get_stack_feature_version

config = Script.get_config()
stack_root = Script.get_stack_root()

default_conf_file = "application.properties"

# get the correct version to use for checking stack features
version_for_stack_feature_checks = get_stack_feature_version(config)

if check_stack_feature(StackFeature.ATLAS_UPGRADE_SUPPORT, version_for_stack_feature_checks):
  default_conf_file = "atlas-application.properties"

conf_file = default("/configurations/atlas-env/metadata_conf_file", default_conf_file)
conf_dir = format("{stack_root}/current/atlas-server/conf")
pid_dir = default("/configurations/atlas-env/metadata_pid_dir", "/var/run/atlas")
pid_file = format("{pid_dir}/atlas.pid")

metadata_user = default("/configurations/atlas-env/metadata_user", None)
hbase_user = default("/configurations/hbase-env/hbase_user", None)
kafka_user = default("/configurations/kafka-env/kafka_user", None)

# Security related/required params
hostname = config['hostname']
security_enabled = default("/configurations/cluster-env/security_enabled", None)
kinit_path_local = get_kinit_path(default('/configurations/kerberos-env/executable_search_paths', None))
tmp_dir = Script.get_tmp_dir()

stack_name = default("/hostLevelParams/stack_name", None)
hadoop_conf_dir = conf_select.get_hadoop_conf_dir()
hadoop_bin_dir = stack_select.get_hadoop_dir("bin")


text:
//%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// 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.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////

#ifndef __UNIX_LOCALFILESYSTEM_H
#define __UNIX_LOCALFILESYSTEM_H

#include "FileSystem/UNIX_FileSystem.h"

#include "UNIX_LocalFileSystemDeps.h"

#define PROPERTY_FREE_INODES				"FreeInodes"
#define PROPERTY_TOTAL_INODES				"TotalInodes"
#define PROPERTY_FS_RESERVED_CAPACITY				"FSReservedCapacity"

class UNIX_LocalFileSystem :
	public UNIX_FileSystem
{
public:

	UNIX_LocalFileSystem();
	~UNIX_LocalFileSystem();

	virtual Boolean initialize();
	virtual Boolean load(int&);
	virtual Boolean finalize();
	virtual Boolean find(Array<CIMKeyBinding>&);
	virtual Boolean validateKey(CIMKeyBinding&) const;
	virtual void setScope(CIMName);

	virtual Boolean getInstanceID(CIMProperty&) const;
	virtual String getInstanceID() const;
	virtual Boolean getCaption(CIMProperty&) const;
	virtual String getCaption() const;
	virtual Boolean getDescription(CIMProperty&) const;
	virtual String getDescription() const;
	virtual Boolean getElementName(CIMProperty&) const;
	virtual String getElementName() const;
	virtual Boolean getInstallDate(CIMProperty&) const;
	virtual CIMDateTime getInstallDate() const;
	virtual Boolean getName(CIMProperty&) const;
	virtual String getName() const;
	virtual Boolean getOperationalStatus(CIMProperty&) const;
	virtual Array<Uint16> getOperationalStatus() const;
	virtual Boolean getStatusDescriptions(CIMProperty&) const;
	virtual Array<String> getStatusDescriptions() const;
	virtual Boolean getStatus(CIMProperty&) const;
	virtual String getStatus() const;
	virtual Boolean getHealthState(CIMProperty&) const;
	virtual Uint16 getHealthState() const;
	virtual Boolean getCommunicationStatus(CIMProperty&) const;
	virtual Uint16 getCommunicationStatus() const;
	virtual Boolean getDetailedStatus(CIMProperty&) const;
	virtual Uint16 getDetailedStatus() const;
	virtual Boolean getOperatingStatus(CIMProperty&) const;
	virtual Uint16 getOperatingStatus() const;
	virtual Boolean getPrimaryStatus(CIMProperty&) const;
	virtual Uint16 getPrimaryStatus() const;
	virtual Boolean getEnabledState(CIMProperty&) const;
	virtual Uint16 getEnabledState() const;
	virtual Boolean getOtherEnabledState(CIMProperty&) const;
	virtual String getOtherEnabledState() const;
	virtual Boolean getRequestedState(CIMProperty&) const;
	virtual Uint16 getRequestedState() const;
	virtual Boolean getEnabledDefault(CIMProperty&) const;
	virtual Uint16 getEnabledDefault() const;
	virtual Boolean getTimeOfLastStateChange(CIMProperty&) const;
	virtual CIMDateTime getTimeOfLastStateChange() const;
	virtual Boolean getAvailableRequestedStates(CIMProperty&) const;
	virtual Array<Uint16> getAvailableRequestedStates() const;
	virtual Boolean getTransitioningToState(CIMProperty&) const;
	virtual Uint16 getTransitioningToState() const;
	virtual Boolean getCSCreationClassName(CIMProperty&) const;
	virtual String getCSCreationClassName() const;
	virtual Boolean getCSName(CIMProperty&) const;
	virtual String getCSName() const;
	virtual Boolean getCreationClassName(CIMProperty&) const;
	virtual String getCreationClassName() const;
	virtual Boolean getRoot(CIMProperty&) const;
	virtual String getRoot() const;
	virtual Boolean getBlockSize(CIMProperty&) const;
	virtual Uint64 getBlockSize() const;
	virtual Boolean getFileSystemSize(CIMProperty&) const;
	virtual Uint64 getFileSystemSize() const;
	virtual Boolean getAvailableSpace(CIMProperty&) const;
	virtual Uint64 getAvailableSpace() const;
	virtual Boolean getReadOnly(CIMProperty&) const;
	virtual Boolean getReadOnly() const;
	virtual Boolean getEncryptionMethod(CIMProperty&) const;
	virtual String getEncryptionMethod() const;
	virtual Boolean getCompressionMethod(CIMProperty&) const;
	virtual String getCompressionMethod() const;
	virtual Boolean getCaseSensitive(CIMProperty&) const;
	virtual Boolean getCaseSensitive() const;
	virtual Boolean getCasePreserved(CIMProperty&) const;
	virtual Boolean getCasePreserved() const;
	virtual Boolean getCodeSet(CIMProperty&) const;
	virtual Array<Uint16> getCodeSet() const;
	virtual Boolean getMaxFileNameLength(CIMProperty&) const;
	virtual Uint32 getMaxFileNameLength() const;
	virtual Boolean getClusterSize(CIMProperty&) const;
	virtual Uint32 getClusterSize() const;
	virtual Boolean getFileSystemType(CIMProperty&) const;
	virtual String getFileSystemType() const;
	virtual Boolean getPersistenceType(CIMProperty&) const;
	virtual Uint16 getPersistenceType() const;
	virtual Boolean getOtherPersistenceType(CIMProperty&) const;
	virtual String getOtherPersistenceType() const;
	virtual Boolean getNumberOfFiles(CIMProperty&) const;
	virtual Uint64 getNumberOfFiles() const;
	virtual Boolean getFreeInodes(CIMProperty&) const;
	virtual Uint64 getFreeInodes() const;
	virtual Boolean getTotalInodes(CIMProperty&) const;
	virtual Uint64 getTotalInodes() const;
	virtual Boolean getFSReservedCapacity(CIMProperty&) const;
	virtual Uint64 getFSReservedCapacity() const;

private:
	CIMName currentScope;

#	include "UNIX_LocalFileSystemPrivate.h"

};

#endif /* UNIX_LOCALFILESYSTEM */


text:
function notification(text, lifetime, className) {

    lifetime   = (typeof lifetime === 'undefined' || lifetime === null) ? 3000 : lifetime;
    className = (typeof className === 'undefined' || className === null) ? '' : className;

    var e = document.createElement('div'),
        timeout = lifetime + 1000;
    e.className = 'notification ' + className;
    e.innerHTML = text;

    document.body.appendChild(e);

    setTimeout(function() {
    	e.classList.add('active');

    	setTimeout(function() {
	    	e.classList.remove('active');
            setTimeout(function() {
                e.remove();
            }, timeout);
	    }, lifetime);
    });

}


text:
Installing Impala drivers
====
To deploy Impala as a JBoss module, download the JDBC 4 drivers from https://www.cloudera.com/downloads/connectors/impala/jdbc.html and drop the
.JAR files listed in `module.xml` into this directory before building the project using OpenShift WildFly S2I build.


text:
package models.database

import models.ReportsModel
import ReportsModel._
import org.joda.time.LocalDate
import play.api.db.slick.Config.driver.simple._

object ReportsDatabase {
  val reports = TableQuery[Reports]
}

case class ReportEntity(world: String, date: LocalDate, detected: Int, banned: Int, deleted: Int)

class Reports(tag: Tag) extends Table[ReportEntity](tag, "report") {
  implicit val dateColumnType = MappedColumnType.base[LocalDate, String]({ dateFormatter.print(_) }, { dateFormatter.parseLocalDate })
  def world = column[String]("world", O.DBType("VARCHAR(5)"))
  def date = column[LocalDate]("date", O.DBType("DATE"))
  def detected = column[Int]("detected", O.Default(0))
  def banned = column[Int]("banned", O.Default(0))
  def deleted = column[Int]("deleted", O.Default(0))
  def pk = primaryKey("pk_entry", (world, date))
  def * = (world, date, detected, banned, deleted) <> (ReportEntity.tupled, ReportEntity.unapply)
}


text:
"""
The MIT License (MIT)

Copyright (c) 2017 Stefan Graupner

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.
"""

class ValidatorException(Exception):
    """ A generic validator exception """

class ObjectValidationFailedException(Exception):
    """ A error occured during validation of an object """

class InvalidSeverityException(Exception):
    """ Raised when a severity for an extra check does not validate """

class ClientException(ValidatorException):
    """ A generic client exception """

class EndpointNotReachableException(ClientException):
    """ An endpoint was not reachable over the network """

class EndpointIsNotAnOParlEndpointException(ClientException):
    """ An endpoint is reachable but not valid oparl """


text:
"""Storage module tests."""

import errno
import os
import pytest
from fs.errors import DirectoryNotEmpty, FSError
from io import BytesIO
from os.path import dirname, exists, getsize, join
from unittest.mock import patch

from invenio_files_rest.errors import FileSizeError, StorageError, \
    UnexpectedFileSizeError
from invenio_files_rest.limiters import FileSizeLimit
from invenio_files_rest.storage import FileStorage, PyFSFileStorage

def test_storage_interface():
    """Test storage interface."""
    s = FileStorage()
    pytest.raises(NotImplementedError, s.open)
    pytest.raises(NotImplementedError, s.initialize)
    pytest.raises(NotImplementedError, s.delete)
    pytest.raises(NotImplementedError, s.save, None)
    pytest.raises(NotImplementedError, s.update, None)
    pytest.raises(NotImplementedError, s.checksum)

def test_pyfs_initialize(pyfs, pyfs_testpath):
    """Test init of files."""
    # Create file object.
    assert not exists(pyfs_testpath)
    uri, size, checksum = pyfs.initialize(size=100)

    assert size == 100
    assert checksum is None
    assert os.stat(pyfs_testpath).st_size == size

    uri, size, checksum = pyfs.initialize()
    assert size == 0
    assert size == os.stat(pyfs_testpath).st_size

def test_pyfs_delete(app, db, dummy_location):
    """Test init of files."""
    testurl = join(dummy_location.uri, 'subpath/data')
    s = PyFSFileStorage(testurl)
    s.initialize(size=100)
    assert exists(testurl)

    s.delete()
    assert not exists(testurl)

    s = PyFSFileStorage(join(dummy_location.uri, 'anotherpath/data'))

    # this used to raise a ResourceNotFound, but fs>=2.0 raises CreateFailed
    # FSError is their last common ancestor
    pytest.raises(FSError, s.delete)

def test_pyfs_delete_fail(pyfs, pyfs_testpath):
    """Test init of files."""
    pyfs.save(BytesIO(b'somedata'))
    os.rename(pyfs_testpath, join(dirname(pyfs_testpath), 'newname'))
    pytest.raises(DirectoryNotEmpty, pyfs.delete)

def test_pyfs_save(pyfs, pyfs_testpath, get_md5):
    """Test basic save operation."""
    data = b'somedata'
    uri, size, checksum = pyfs.save(BytesIO(data))

    assert uri == pyfs_testpath
    assert size == len(data)
    assert checksum == get_md5(data)
    assert exists(pyfs_testpath)
    assert open(pyfs_testpath, 'rb').read() == data

def test_pyfs_save_failcleanup(pyfs, pyfs_testpath, get_md5):
    """Test basic save operation."""
    data = b'somedata'

    def fail_callback(total, size):
        assert exists(pyfs_testpath)
        raise Exception('Something bad happened')

    pytest.raises(
        Exception,
        pyfs.save,
        BytesIO(data), chunk_size=4, progress_callback=fail_callback
    )
    assert not exists(pyfs_testpath)
    assert not exists(dirname(pyfs_testpath))

def test_pyfs_save_callback(pyfs):
    """Test progress callback."""
    data = b'somedata'

    counter = dict(size=0)

    def callback(total, size):
        counter['size'] = size

    uri, size, checksum = pyfs.save(
        BytesIO(data), progress_callback=callback)

    assert counter['size'] == len(data)

def test_pyfs_save_limits(pyfs):
    """Test progress callback."""
    data = b'somedata'
    uri, size, checksum = pyfs.save(BytesIO(data), size=len(data))
    assert size == len(data)

    uri, size, checksum = pyfs.save(BytesIO(data), size_limit=len(data))
    assert size == len(data)

    # Size doesn't match
    pytest.raises(
        UnexpectedFileSizeError, pyfs.save, BytesIO(data), size=len(data) - 1)
    pytest.raises(
        UnexpectedFileSizeError, pyfs.save, BytesIO(data), size=len(data) + 1)

    # Exceeds size limits
    pytest.raises(
        FileSizeError, pyfs.save, BytesIO(data),
        size_limit=FileSizeLimit(len(data) - 1, 'bla'))

def test_pyfs_update(pyfs, pyfs_testpath, get_md5):
    """Test update of file."""
    pyfs.initialize(size=100)
    pyfs.update(BytesIO(b'cd'), seek=2, size=2)
    pyfs.update(BytesIO(b'ab'), seek=0, size=2)

    with open(pyfs_testpath) as fp:
        content = fp.read()
    assert content[0:4] == 'abcd'
    assert len(content) == 100

    # Assert return parameters from update.
    size, checksum = pyfs.update(BytesIO(b'ef'), seek=4, size=2)
    assert size == 2
    assert get_md5(b'ef') == checksum

def test_pyfs_update_fail(pyfs, pyfs_testpath, get_md5):
    """Test update of file."""
    def fail_callback(total, size):
        assert exists(pyfs_testpath)
        raise Exception('Something bad happened')

    pyfs.initialize(size=100)
    pyfs.update(BytesIO(b'ab'), seek=0, size=2)
    pytest.raises(
        Exception,
        pyfs.update,
        BytesIO(b'cdef'),
        seek=2,
        size=4,
        chunk_size=2,
        progress_callback=fail_callback,
    )

    # Partial file can be written to disk!
    with open(pyfs_testpath) as fp:
        content = fp.read()
    assert content[0:4] == 'abcd'
    assert content[4:6] != 'ef'

def test_pyfs_checksum(get_md5):
    """Test fixity."""
    # Compute checksum of license file/
    with open('LICENSE', 'rb') as fp:
        data = fp.read()
        checksum = get_md5(data)

    counter = dict(size=0)

    def callback(total, size):
        counter['size'] = size

    # Now do it with storage interface
    s = PyFSFileStorage('LICENSE', size=getsize('LICENSE'))
    assert checksum == s.checksum(chunk_size=2, progress_callback=callback)
    assert counter['size'] == getsize('LICENSE')

    # No size provided, means progress callback isn't called
    counter['size'] = 0
    s = PyFSFileStorage('LICENSE')
    assert checksum == s.checksum(chunk_size=2, progress_callback=callback)
    assert counter['size'] == 0

def test_pyfs_checksum_fail():
    """Test fixity problems."""
    # Raise an error during checksum calculation
    def callback(total, size):
        raise OSError(errno.EPERM, "Permission")

    s = PyFSFileStorage('LICENSE', size=getsize('LICENSE'))

    pytest.raises(StorageError, s.checksum, progress_callback=callback)

def test_pyfs_send_file(app, pyfs):
    """Test send file."""
    data = b'sendthis'
    uri, size, checksum = pyfs.save(BytesIO(data))

    with app.test_request_context():
        res = pyfs.send_file(
            'myfilename.txt', mimetype='text/plain', checksum=checksum)
        assert res.status_code == 200
        h = res.headers
        assert h['Content-Type'] == 'text/plain; charset=utf-8'
        assert h['Content-Length'] == str(size)
        assert h['Content-MD5'] == checksum[4:]
        assert h['ETag'] == '"{0}"'.format(checksum)

        # Content-Type: application/octet-stream
        # ETag: "b234ee4d69f5fce4486a80fdaf4a4263"
        # Last-Modified: Sat, 23 Jan 2016 06:21:04 GMT
        # Cache-Control: max-age=43200, public
        # Expires: Sat, 23 Jan 2016 19:21:04 GMT
        # Date: Sat, 23 Jan 2016 07:21:04 GMT

        res = pyfs.send_file(
            'myfilename.txt', mimetype='text/plain', checksum='crc32:test')
        assert res.status_code == 200
        assert 'Content-MD5' not in dict(res.headers)

        # Test for absence of Content-Disposition header to make sure that
        # it's not present when as_attachment=False
        res = pyfs.send_file('myfilename.txt', mimetype='text/plain',
                             checksum=checksum, as_attachment=False)
        assert res.status_code == 200
        assert 'attachment' not in res.headers['Content-Disposition']

def test_pyfs_send_file_for_download(app, pyfs):
    """Test send file."""
    data = b'sendthis'
    uri, size, checksum = pyfs.save(BytesIO(data))

    with app.test_request_context():
        # Test for presence of Content-Disposition header to make sure that
        # it's present when as_attachment=True
        res = pyfs.send_file('myfilename.txt', mimetype='text/plain',
                             checksum=checksum, as_attachment=True)
        assert res.status_code == 200
        assert res.headers["Content-Disposition"] == "attachment; filename=myfilename.txt"

def test_pyfs_send_file_xss_prevention(app, pyfs):
    """Test send file."""
    data = b''
    uri, size, checksum = pyfs.save(BytesIO(data))

    with app.test_request_context():
        res = pyfs.send_file(
            'myfilename.html', mimetype='text/html', checksum=checksum)
        assert res.status_code == 200
        h = res.headers
        assert h['Content-Type'] == 'text/plain; charset=utf-8'
        assert h['Content-Length'] == str(size)
        assert h['Content-MD5'] == checksum[4:]
        assert h['ETag'] == '"{0}"'.format(checksum)
        # XSS prevention
        assert h['Content-Security-Policy'] == 'default-src \'none\';'
        assert h['X-Content-Type-Options'] == 'nosniff'
        assert h['X-Download-Options'] == 'noopen'
        assert h['X-Permitted-Cross-Domain-Policies'] == 'none'
        assert h['X-Frame-Options'] == 'deny'
        assert h['X-XSS-Protection'] == '1; mode=block'
        assert h['Content-Disposition'] == 'inline'

        # Image
        h = pyfs.send_file('image.png', mimetype='image/png').headers
        assert h['Content-Type'] == 'image/png'
        assert h['Content-Disposition'] == 'inline'

        # README text file
        h = pyfs.send_file('README').headers
        assert h['Content-Type'] == 'text/plain; charset=utf-8'
        assert h['Content-Disposition'] == 'inline'

        # Zip
        h = pyfs.send_file('archive.zip').headers
        assert h['Content-Type'] == 'application/octet-stream'
        assert h['Content-Disposition'] == 'attachment; filename=archive.zip'

        # PDF
        h = pyfs.send_file('doc.pdf').headers
        assert h['Content-Type'] == 'application/octet-stream'
        assert h['Content-Disposition'] == 'attachment; filename=doc.pdf'

def test_pyfs_send_file_fail(app, pyfs):
    """Test send file."""
    pyfs.save(BytesIO(b'content'))

    with patch('invenio_files_rest.storage.base.send_stream') as send_stream:
        send_stream.side_effect = OSError(errno.EPERM, "Permission problem")
        with app.test_request_context():
            pytest.raises(StorageError, pyfs.send_file, 'test.txt')

def test_pyfs_copy(pyfs, dummy_location):
    """Test send file."""
    s = PyFSFileStorage(join(dummy_location.uri, 'anotherpath/data'))
    s.save(BytesIO(b'otherdata'))

    pyfs.copy(s)
    fp = pyfs.open()
    assert fp.read() == b'otherdata'

def test_non_unicode_filename(app, pyfs):
    """Test sending the non-unicode filename in the header."""
    data = b'HelloWorld'
    uri, size, checksum = pyfs.save(BytesIO(data))

    with app.test_request_context():
        res = pyfs.send_file(
            u'żółć.dat', mimetype='application/octet-stream',
            checksum=checksum)
        assert res.status_code == 200
        assert set(res.headers['Content-Disposition'].split('; ')) == \
            set(["attachment", "filename=zoc.dat",
                 "filename*=UTF-8''%C5%BC%C3%B3%C5%82%C4%87.dat"])

    with app.test_request_context():
        res = pyfs.send_file(
            'żółć.txt', mimetype='text/plain', checksum=checksum)
        assert res.status_code == 200
        assert res.headers['Content-Disposition'] == 'inline'


text:
package org.sirix.access.node.xml;

import java.nio.file.Files;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.sirix.Holder;
import org.sirix.XmlTestHelper;
import org.sirix.XmlTestHelper.PATHS;
import org.sirix.access.Databases;
import org.sirix.access.ResourceConfiguration;
import org.sirix.api.xml.XmlResourceSession;
import org.sirix.api.xml.XmlNodeReadOnlyTrx;
import org.sirix.node.NodeKind;

import static org.junit.Assert.*;

public final class XmlNodeReadOnlyTrxImplTest {

  private Holder holder;

  @Before
  public void setUp() {
    XmlTestHelper.deleteEverything();
    XmlTestHelper.createTestDocument();
    holder = Holder.generateRtx();
  }

  @After
  public void tearDown() {
    holder.close();
    XmlTestHelper.closeEverything();
  }

  @Test
  public void testEmptyRtx() {
    assertFalse(Files.exists(PATHS.PATH2.getFile()));
    Databases.createXmlDatabase(PATHS.PATH2.getConfig());

    try (final var db = Databases.openXmlDatabase(PATHS.PATH2.getFile())) {
      db.createResource(new ResourceConfiguration.Builder(XmlTestHelper.RESOURCE).build());
      try (final XmlResourceSession resMgr = db.beginResourceSession(XmlTestHelper.RESOURCE);
           final XmlNodeReadOnlyTrx rtx = resMgr.beginNodeReadOnlyTrx()) {
        assertEquals(0, rtx.getRevisionNumber());
      }
    }
  }

  @Test
  public void testDocumentRoot() {
    assertTrue(holder.getXmlNodeReadTrx().moveToDocumentRoot());
    assertEquals(NodeKind.XML_DOCUMENT, holder.getXmlNodeReadTrx().getKind());
    assertFalse(holder.getXmlNodeReadTrx().hasParent());
    assertFalse(holder.getXmlNodeReadTrx().hasLeftSibling());
    assertFalse(holder.getXmlNodeReadTrx().hasRightSibling());
    assertTrue(holder.getXmlNodeReadTrx().hasFirstChild());
  }

  @Test
  public void testConventions() {

    // ReadTransaction Convention 1.
    assertTrue(holder.getXmlNodeReadTrx().moveToDocumentRoot());
    long key = holder.getXmlNodeReadTrx().getNodeKey();

    // ReadTransaction Convention 2.
    assertEquals(holder.getXmlNodeReadTrx().hasParent(), holder.getXmlNodeReadTrx().moveToParent());
    assertEquals(key, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasFirstChild(), holder.getXmlNodeReadTrx().moveToFirstChild());
    assertEquals(1L, holder.getXmlNodeReadTrx().getNodeKey());

    assertFalse(holder.getXmlNodeReadTrx().moveTo(Integer.MAX_VALUE));
    assertFalse(holder.getXmlNodeReadTrx().moveTo(Integer.MIN_VALUE));
    assertFalse(holder.getXmlNodeReadTrx().moveTo(Long.MAX_VALUE));
    assertFalse(holder.getXmlNodeReadTrx().moveTo(Long.MIN_VALUE));
    assertEquals(1L, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasRightSibling(), holder.getXmlNodeReadTrx().moveToRightSibling());
    assertEquals(1L, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasFirstChild(), holder.getXmlNodeReadTrx().moveToFirstChild());
    assertEquals(4L, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasRightSibling(), holder.getXmlNodeReadTrx().moveToRightSibling());
    assertEquals(5L, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasLeftSibling(), holder.getXmlNodeReadTrx().moveToLeftSibling());
    assertEquals(4L, holder.getXmlNodeReadTrx().getNodeKey());

    assertEquals(holder.getXmlNodeReadTrx().hasParent(), holder.getXmlNodeReadTrx().moveToParent());
    assertEquals(1L, holder.getXmlNodeReadTrx().getNodeKey());
  }

}


text:
int rank, size;
MPI_Comm comm;
// logical variable
// 1 if worker is done and waiting for more
// 0 if it is busy
int iter_counter;
int is_worker_ready;
// mutex
pthread_mutex_t mutex;

void* task_parser();
void task_getter();
int get_task_from_queue(int iteration);

// returns -1 if there is no free tasks
// int find_neartest_free_task(int* tasks_status);

int main(int argc, char** argv) {
	int provided;

	// prepare MPI
	comm = MPI_COMM_WORLD;
	MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
	MPI_Comm_size(comm, &size);
	MPI_Comm_rank(comm, &rank);

	//prepare data
	//tasks_list = (int*) malloc(TASKS_LIST_SIZE * sizeof(int));
	//prepare_tasks(rank);

	//prepare working thread
	pthread_t working_thread;
	pthread_attr_t attrs;

	if (pthread_attr_init(&attrs) != 0) {
		perror("Cannot init thread attrs");
		abort();
	}
	if (pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_JOINABLE) != 0) {
		perror("Cannot set thread joinable");
		abort();
	}
	if (pthread_mutex_init(&mutex, NULL) != 0) {
		perror("Cannot init mutex");
		abort();
	}
	pthread_create(&working_thread, &attrs, task_parser, NULL);
	pthread_attr_destroy(&attrs);

	// start listening for messages from another processes
	task_getter();

	// ok, going home
	if (pthread_join(working_thread, NULL) != 0) {
		perror("Cannot join thread");
		abort();
	}
	MPI_Finalize();
	return 0;
}

void task_getter() {
	int* states = (int*) malloc(sizeof(int) * size);
	int worker_state;
	int current_state;
	int everyone_is_completed = 0;
	int sum;
	int task;
	int counter;
	current_task = rank;
	iter_counter = 1;
	while(1) {

		// check is everyone complete
		current_state = (current_task == -1) ? 1 : 0;
		MPI_Allreduce(&current_state, &everyone_is_completed, 1, MPI_INT, MPI_PROD, comm);
		if (everyone_is_completed) {
			printf("bye-bye\n");
			break;
		}

		//check how many processes complete
		pthread_mutex_lock(&mutex);
		worker_state = is_worker_ready;
		pthread_mutex_unlock(&mutex);

		MPI_Allgather(&worker_state, 1, MPI_INT, states, 1, MPI_INT, comm);

		//get new task
		counter = 0;
		for (int i = 0; i < size; i++) {
			if (states[i] == 1) {
				counter++;
				if (rank == i) {
					task = get_task_from_queue(iter_counter+counter);
					printf("%d\n", iter_counter + counter);
					counter = 1;
					break;
				}
			}
		}
		// get number of iterations
		MPI_Allreduce(&counter, &sum, 1, MPI_INT, MPI_SUM, comm);
		iter_counter += sum;

		if (worker_state) {
			pthread_mutex_lock(&mutex);
			current_task = task;
			is_worker_ready = 0;
			pthread_mutex_unlock(&mutex);
		}
	}
}

void* task_parser() {
	int task;
	double result;
	is_worker_ready = 0;
	int iwr;
	while (task != -1) {
		pthread_mutex_lock(&mutex);
		iwr = is_worker_ready;
		pthread_mutex_unlock(&mutex);
		if (!iwr) {
			pthread_mutex_lock(&mutex);
			task = current_task;
			pthread_mutex_unlock(&mutex);
			for (int i = 0; i < SIZE_MULTIPLIER * task; i++) {
				result+=sqrt(i);
			}
			pthread_mutex_lock(&mutex);
			is_worker_ready = 1;
			pthread_mutex_unlock(&mutex);
		}
	}
	return NULL;
}

int get_task_from_queue(int iteration) {
	return iteration < N ? abs((rank - (iteration%size))) : -1;
}


text:
#include "precompiled.h"
#include "util_time.h"
#include <math.h>

#include <iostream>
#include <ctime>
#include <sstream>
#include <locale>
#include <iomanip>

#include "util_lexical_cast.hpp"

NS_DS_BEGIN
NS_UTIL_BEGIN
//-------------------------
//class: CTimeSpan
CTimeSpan::CTimeSpan()
{

}

CTimeSpan::CTimeSpan(int seconds, int minutes/*=0*/, int hours/*=0*/, int days/*=0*/) :duration_((days * 24 + hours)*3600+minutes*60+seconds)
{

}

CTimeSpan::CTimeSpan(const CTimeSpan& t)
{
	Reset(t);
}

CTimeSpan::~CTimeSpan()
{

}

void CTimeSpan::Reset(int seconds, int minutes/*=0*/, int hours/*=0*/, int days/*=0*/)
{
	duration_ = (days * 24 + hours) * 3600 + minutes * 60 + seconds;
}

void CTimeSpan::Reset(const CTimeSpan& t)
{
	duration_ = t.duration_;
}

ds_int32 CTimeSpan::GetSeconds()
{
	return duration_;
}

std::string CTimeSpan::ToString() const
{
	std::string time_span_string;
	ds_int32 total = duration_;
	ds_int32 seconds = total % 60;
	ds_int32 minutes = (total / 60) % 60;
	ds_int32 hours = total / 3600;

	if (hours<10){
		time_span_string += "0";
	}
	time_span_string += dios::util::lexical_cast<std::string>(hours);
	time_span_string += ":";
	if (minutes < 10){
		time_span_string += "0";
	}
	time_span_string += dios::util::lexical_cast<std::string>(minutes);
	time_span_string += ":";
	if (seconds < 10){
		time_span_string += "0";
	}
	time_span_string += dios::util::lexical_cast<std::string>(seconds);

	return time_span_string;
}

CTimeSpan CTimeSpan::operator+(CTimeSpan& time_span)
{
	CTimeSpan tReturn;
	tReturn.duration_ += time_span.duration_;
	return tReturn;
}

CTimeSpan CTimeSpan::operator-(CTimeSpan& time_span)
{
	CTimeSpan tReturn;
	tReturn.duration_ -= time_span.duration_;
	return tReturn;
}

bool CTimeSpan::operator>(const CTimeSpan& t) const
{
	return duration_ > t.duration_;
}

bool CTimeSpan::operator<(const CTimeSpan& t) const
{
	return duration_ < t.duration_;
}

bool CTimeSpan::operator>=(const CTimeSpan& t) const
{
	return duration_ >= t.duration_;
}

bool CTimeSpan::operator<=(const CTimeSpan& t) const
{
	return duration_ <= t.duration_;
}

bool CTimeSpan::operator==(const CTimeSpan& t) const
{
	return duration_ == t.duration_;
}

//-----------------
//class CTime

CTime::CTime()
{
	FromTimePoint(std::chrono::system_clock::now());
}

CTime::CTime(const std::string& time)
{
	FromString(time);
}

CTime::CTime(const std::time_t& tt)
{
	FromCTime(tt);
}

CTime::CTime(const CTime& t)
{
	Copy(t);
}

CTime::CTime(const std::chrono::system_clock::time_point& time)
{
	FromTimePoint(time);
}

CTime::~CTime(){}

CTime CTime::Now()
{
	CTime time(std::chrono::system_clock::now());
	return time;
}

void CTime::FromString(const std::string& time)
{
	try	{
		std::tm t = {};
		std::istringstream ss(time);
		// ss.imbue(std::locale("de_DE.utf-8"));
		ss >> std::get_time(&t, "%Y-%m-%d %H:%M:%S");
		std::time_t time_t_v = std::mktime(&t);
		FromCTime(time_t_v);
	}
	catch (...)	{
		FromTimePoint(std::chrono::system_clock::now());
	}
}

void CTime::FromCTime(const time_t& t)
{
	time_ = t;
}

void CTime::FromTimePoint(const std::chrono::system_clock::time_point& t)
{
	FromCTime(std::chrono::system_clock::to_time_t(t));
}

void CTime::Copy(const CTime& t)
{
	time_ = t.time_;
}

ds_uint32 CTime::GetSeconds(void) const
{
	return time_;
}

void CTime::NextDays(int days/*=1*/, int hours/*=0*/)
{
	auto time = std::chrono::system_clock::from_time_t(time_);
	time += std::chrono::hours(24*days+hours);
	FromTimePoint(time);
}

bool			CTime::operator>	(const CTime& t) const { return time_ > t.time_; }
bool			CTime::operator<	(const CTime& t) const { return time_ < t.time_; }
bool			CTime::operator>=	(const CTime& t) const { return time_ >= t.time_; }
bool			CTime::operator<=	(const CTime& t) const { return time_ <= t.time_; }
bool			CTime::operator==	(const CTime& t) const { return time_ == t.time_; }
bool			CTime::operator!=	(const CTime& t) const { return time_ != t.time_; }
CTime			CTime::operator-	(const CTimeSpan& tSpan) const { CTime rtn(time_ - tSpan.duration_); return rtn; }
CTimeSpan		CTime::operator-	(const CTime& t) const { CTimeSpan span; span.duration_ = time_ - t.time_; return span; }
CTime			CTime::operator+	(const CTimeSpan& tSpan) const { CTime rtn(time_ + tSpan.duration_); return rtn; }
void			CTime::operator-=	(const CTimeSpan& tSpan) { time_ -= tSpan.duration_; }
void			CTime::operator+=	(const CTimeSpan& tSpan) { time_ += tSpan.duration_; }

//char*
bool			CTime::operator>	(const std::string& param) const { CTime time(param); return (*this)> time; }
bool			CTime::operator<	(const std::string& param) const { CTime time(param); return (*this)< time; }
bool			CTime::operator>=	(const std::string& param) const { CTime time(param); return (*this) >= time; }
bool			CTime::operator<=	(const std::string& param) const { CTime time(param); return (*this) <= time; }
bool			CTime::operator==	(const std::string& param) const { CTime time(param); return (*this) == time; }
CTimeSpan		CTime::operator-	(const std::string& param) const { CTime time(param); return (*this) - time; }

std::string CTime::ToString() const
{
	std::ostringstream ss;
	// ss.imbue(std::locale("de_DE.utf-8"));
	ss << std::put_time(std::localtime(&time_), "%Y-%m-%d %H:%M:%S");
	return ss.str();
}

std::string CTime::ToDateString() const
{
	std::ostringstream ss;
	// ss.imbue(std::locale("de_DE.utf-8"));
	ss << std::put_time(std::localtime(&time_), "%Y-%m-%d");
	return ss.str();
}

std::string CTime::ToTimeString() const
{
	std::ostringstream ss;
	// ss.imbue(std::locale("de_DE.utf-8"));
	ss << std::put_time(std::localtime(&time_), "%H:%M:%S");
	return ss.str();
}

NS_UTIL_END
NS_DS_END


text:
<?php
// module/Album/src/Album/Model/Album.php:
namespace Album\Model;

use Zend\InputFilter\Factory as InputFactory;
use Zend\InputFilter\InputFilter;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\InputFilter\InputFilterInterface;

class Album implements InputFilterAwareInterface
{
    public $id;
    public $email;
    public $username;
    public $display_name;
    public $image;
    public $activity;
    protected $inputFilter;

    public function exchangeArray($data)
    {
        $this->id     = (isset($data['id']))     ? $data['id']     : ((isset($data['user_id'])) ? $data['user_id'] : null);
        $this->email = (isset($data['email'])) ? $data['email'] : null;
        $this->username  = (isset($data['username']))  ? $data['username']  : null;
        $this->display_name = (isset($data['display_name'])) ? $data['display_name'] : null;
        $this->image  = (isset($data['image']))  ? $data['image']  : null;
        $this->activity  = (isset($data['activity']))  ? $data['activity']  : null;
    }

     // Add the following method:
    public function getArrayCopy()
    {
        return get_object_vars($this);
    }

    public function setInputFilter(InputFilterInterface $inputFilter)
    {
        throw new \Exception("Not used");
    }

    public function getInputFilter()
    {
        if (!$this->inputFilter) {
            $inputFilter = new InputFilter();
            $factory     = new InputFactory();

            $inputFilter->add($factory->createInput(array(
                'name'     => 'id',
                'required' => true,
                'filters'  => array(
                    array('name' => 'Int'),
                ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'username',
                'required' => true,
                'filters'  => array(
                    array('name' => 'StripTags'),
                    array('name' => 'StringTrim'),
                ),
                'validators' => array(
                    array(
                        'name'    => 'StringLength',
                        'options' => array(
                            'encoding' => 'UTF-8',
                            'min'      => 1,
                            'max'      => 100,
                        ),
                    ),
                ),
            )));

            $inputFilter->add($factory->createInput(array(
                'name'     => 'display_name',
                'required' => true,
                'filters'  => array(
                    array('name' => 'StripTags'),
                    array('name' => 'StringTrim'),
                ),
                'validators' => array(
                    array(
                        'name'    => 'StringLength',
                        'options' => array(
                            'encoding' => 'UTF-8',
                            'min'      => 1,
                            'max'      => 100,
                        ),
                    ),
                ),
            )));

            $this->inputFilter = $inputFilter;
        }

        return $this->inputFilter;
    }
}


text:
#ifndef __PEPXML_DELEGATES_H__
#define __PEPXML_DELEGATES_H__

#ifdef __cplusplus
extern "C"
{
#endif
/*
	Here we define a rudimentary delegate structure and interfaces that allows the future
	implementation of reading, printing and analyzing of custom algorithm parts of the
	pepxml files.
*/

/*	Interface definition. Each custom algorithm should provide 3 functions:
		- key: key that will trigger the use of the specified funct ions
		- read function, reads the intended part designated with the given key
		- write function, writes the custom format to a string of type char*
		- property function, returns the value of a certain key somewhere stored in the custom structure
*/
typedef struct pepxml_delegate
{
	char* key;
	char* context;
	void* (*pread_function)(char*);
	char* (*write_function)(void*);
	void* (*property_function)(char*, void*);

} delegate_type, *pdelegate_type;

/* List of delegates */
typedef struct pepxml_delegate_list
{
	pdelegate_type*	dlist;	/* list of pointers to delegates */
	int				size;	/* size of the list */

} delegate_list, *pdelegate_list;

/* Function that creates and configures a delegate */
pdelegate_type make_delegate(char* key, char* context, void* (*pread_function)(char*), char* (*write_function)(void*), void* (*property_function)(char*, void*));

/* Function that creates a delegate list */
pdelegate_list make_delegate_list();

/* Function that adds a delegate to the list */
void add_delegate_to_list(pdelegate_list list, pdelegate_type delegate_t);

/* Function that helps finding the correct delegate, NULL if key is not found in the array */
pdelegate_type get_delegate(char* key, char* context, pdelegate_list list);

#ifdef __cplusplus
}
#endif

#endif


text:
===========
Foundations
===========

You should read through the :doc:`quickstart <quickstart>` before reading this document.

.. _quickstart: quickstart.html

Distributed computing is hard for two reasons:

1.  Consistent coordination of distributed systems requires sophistication
2.  Concurrent network programming is tricky and error prone

The foundations of ``dask.distributed`` provide abstractions to hide some
complexity of concurrent network programming (#2).  These abstractions ease the
construction of sophisticated parallel systems (#1) in a safer environment.
However, as with all layered abstractions, ours has flaws.  Critical feedback
is welcome.

Concurrency with Tornado Coroutines
===================================

Worker and Scheduler nodes operate concurrently.  They serve several overlapping
requests and perform several overlapping computations at the same time without
blocking.  There are several approaches for concurrent programming, we've
chosen to use Tornado for the following reasons:

1.  Developing and debugging is more comfortable without threads
2.  `Tornado's documentation`_ is excellent
3.  Stackoverflow coverage is excellent
4.  Performance is satisfactory

.. _`Tornado's documentation`: https://tornado.readthedocs.io/en/latest/coroutine.html

Endpoint-to-endpoint Communication
==================================

The various distributed endpoints (Client, Scheduler, Worker) communicate
by sending each other arbitrary Python objects.  Encoding, sending and then
decoding those objects is the job of the :ref:`communication layer <communications>`.

Ancillary services such as a Bokeh-based Web interface, however, have their
own implementation and semantics.

Protocol Handling
=================

While the abstract communication layer can transfer arbitrary Python
objects (as long as they are serializable),  participants in a ``distributed``
cluster concretely obey the distributed :ref:`protocol`, which specifies
request-response semantics using a well-defined message format.

Dedicated infrastructure in ``distributed`` handles the various aspects
of the protocol, such as dispatching the various operations supported by
an endpoint.

Servers
-------

Worker, Scheduler, and Nanny objects all inherit from a ``Server`` class.

.. autoclass:: distributed.core.Server

RPC
---

To interact with remote servers we typically use ``rpc`` objects which
expose a familiar method call interface to invoke remote operations.

.. autoclass:: distributed.core.rpc

Examples
========

Here is a small example using distributed.core to create and interact with a
custom server.

Server Side
-----------

.. code-block:: python

   import asyncio
   from distributed.core import Server

   def add(comm, x=None, y=None):  # simple handler, just a function
       return x + y

   async def stream_data(comm, interval=1):  # complex handler, multiple responses
       data = 0
       while True:
           await asyncio.sleep(interval)
           data += 1
           await comm.write(data)

   s = Server({'add': add, 'stream_data': stream_data})
   s.listen('tcp://:8888')   # listen on TCP port 8888

   asyncio.get_event_loop().run_forever()

Client Side
-----------

.. code-block:: python

   import asyncio
   from distributed.core import connect

   async def f():
       comm = await connect('tcp://127.0.0.1:8888')
       await comm.write({'op': 'add', 'x': 1, 'y': 2})
       result = await comm.read()
       await comm.close()
       print(result)

   >>> asyncio.get_event_loop().run_until_complete(g())
   3

   async def g():
       comm = await connect('tcp://127.0.0.1:8888')
       await comm.write({'op': 'stream_data', 'interval': 1})
       while True:
           result = await comm.read()
           print(result)

   >>> asyncio.get_event_loop().run_until_complete(g())
   1
   2
   3
   ...

Client Side with ``rpc``
------------------------

RPC provides a more pythonic interface.  It also provides other benefits, such
as using multiple streams in concurrent cases.  Most distributed code uses
``rpc``.  The exception is when we need to perform multiple reads or writes, as
with the stream data case above.

.. code-block:: python

   import asyncio
   from distributed.core import rpc

   async def f():
       # comm = await connect('tcp://127.0.0.1', 8888)
       # await comm.write({'op': 'add', 'x': 1, 'y': 2})
       # result = await comm.read()
       with rpc('tcp://127.0.0.1:8888') as r:
           result = await r.add(x=1, y=2)

       print(result)

   >>> asyncio.get_event_loop().run_until_complete(f())
   3


text:
var UU5 = UU5 || {};
UU5.DocKit = UU5.DocKit || {};
UU5.DocKit.data = UU5.DocKit.data || {};

UU5.DocKit.data.uu5_layout_flc_mixin = {
  mixinName: "UU5.Layout.FlcMixin",
  sourceFile: "../../data/source/uu5-layout-flc-mixin.js",
  cssFile: null,
  descLSI: {
    en: `ToDo!!!`,
    cs: `<UU5.Bricks.Blockquote.bgSuccess> Mixin <UU5.Bricks.Code content='UU5.Layout.FlcMixin'/> je ve
frameworku <UU5.DocKit.Bricks.LinkUU5/> mixin, který z komponenty, která ho splňuje, udělá komponentu typu <UU5.Bricks.Code content='flc' />.
</UU5.Bricks.Blockquote.bgSuccess>
<UU5.Bricks.Blockquote.bgInfo>
Při tvorbě komponenty typu <UU5.Bricks.Code content='flc' /> pomocí  <UU5.Bricks.Code content='UU5.Layout.FlcMixin'/>  je potřeba použít jako hlavní <UU5.Bricks.Code content='tag'/> při vykreslování vaší vlastní komponenty přímo
 <UU5.Bricks.Code content='UU5.Layout.Flc'/>. Takto vytvořená komponenta už může obsahovat přímo <UU5.Bricks.Code content='Bricks' /> a nemusí obsahovat další <UU5.Bricks.Code content='flc' />. Tato komponenta může být rozšířena o vlastní metody a funkce.
</UU5.Bricks.Blockquote.bgInfo>
`
  },
  demoExample: {
    src: '../../data/examples/exampleUU5LayoutFlcMixin01.html',
    descLSI: {
      en: `ToDo!!!`,
      cs: `Příklad představuje vytvoření vlastní komponenty <UU5.Bricks.Code content='UU5.Example.MyFlc'/>, která splňuje <UU5.Bricks.Code content='UU5.Layout.FlcMixin'/>.
Komponenta <UU5.Bricks.Code content='UU5.Example.MyFlc'/> se tak chová stejně, jako komponenta <UU5.DocKit.Bricks.Link tagName='UU5.Layout.Flc' />.`
    },
  },
  demoExampleHintLSI: {
    cs: ``
  },
  mixins: ['<UU5.DocKit.Bricks.Link tagName="UU5.Layout.LayoutMixin" />'],
  mixinsDescLSI: null,
  staticsDescLSI: {
    en: `ToDo!!!`,
    cs: ``
  },
  props: [],
  propsDescLSI: null,
  interface: [
    {
      name: 'hasUU5_Layout_FlcMixin',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[bool] component.hasUU5_Layout_FlcMixin()'/>

Metoda vrací <UU5.Bricks.Code content='true' />, pokud komponenta splňuje <UU5.Bricks.Code content='UU5.Layout.FlcMixin' />.
`
      }
    },
    {
      name: 'getUU5_Layout_FlcMixinProps',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getUU5_Layout_FlcMixinProps()'/>

Metoda vrací objekt s hodnotou vlastnosti <UU5.Bricks.Code content='overflow' />, kterou přebírá z <UU5.Bricks.Code content='UU5.Common.BaseMixin' />.
`
      }
    },
    {
      name: 'getUU5_Layout_FlcMixinPropsToPass',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getUU5_Layout_flcMixinPropsToPass()'/>

Props, které se předávají do hlavního tagu v komponentě. Mohou být touto metodou modifikovány.`
      }
    },
    {
      name: 'getWrapper',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getWrapper()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.WrapperMixin' />.`
      }
    },
    {
      name: 'getWrapperCollection',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getWrapperCollection()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.WrapperCollectionMixin' />.`
      }
    },
    {
      name: 'getWrapperIndex',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[number] component.getWrapperIndex()'/>

Metoda vrací pořadí nadřazené komponenty typu <UU5.Bricks.Code content='wrapper' /> v jí nadřazené komponentě typu
<UU5.Bricks.Code content='column' />.`
      }
    },
    {
      name: 'getColumn',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getColumn()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.ColumnMixin' />.`
      }
    },
    {
      name: 'getColumnCollection',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getColumnCollection()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.ColumnCollectionMixin' />.`
      }
    },
    {
      name: 'getColumnIndex',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[number] component.getColumnIndex()'/>

Metoda vrací pořadí nadřazené komponenty typu <UU5.Bricks.Code content='column' /> v jí nadřazené komponentě typu
<UU5.Bricks.Code content='row' />.`
      }
    },
    {
      name: 'getRow',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getRow()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.RowMixin' />.`
      }
    },
    {
      name: 'getRowCollection',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getRowCollection()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.RowCollectionMixin' />.`
      }
    },
    {
      name: 'getRowIndex',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[number] component.getRowIndex()'/>

Metoda vrací pořadí nadřazené komponenty typu <UU5.Bricks.Code content='row' /> v jí nadřazené komponentě typu
<UU5.Bricks.Code content='container' />.`
      }
    },
    {
      name: 'getContainer',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getContainer()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.ContainerMixin' />.`
      }
    },
    {
      name: 'getContainerCollection',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getContainerCollection()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.ContainerCollectionMixin' />.`
      }
    },
    {
      name: 'getContainerIndex',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[number] component.getContainerIndex()'/>

Metoda vrací pořadí nadřazené komponenty typu <UU5.Bricks.Code content='container' /> v jí nadřazené komponentě typu
<UU5.Bricks.Code content='root' />.`
      }
    },
    {
      name: 'getRoot',
      descLSI: {
        cs: `<UU5.Bricks.Code content='[object] component.getRoot()'/>

Metoda najde nadřazenou komponentu, která splňuje
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.RootMixin' />.`
      }
    }
  ],
  interfaceDescLSI: null,
  examples: [{
    src: '../../data/examples/exampleUU5LayoutFlcMixin01.html',
    descLSI: {
      en: `ToDo!!!`,
      cs: `Příklad představuje vytvoření vlastní komponenty <UU5.Bricks.Code content='UU5.Example.MyFlc'/>, která splňuje <UU5.Bricks.Code content='UU5.Layout.FlcMixin'/>.
Komponenta <UU5.Bricks.Code content='UU5.Example.MyFlc'/> se tak chová stejně, jako komponenta
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.Flc' />.`
    },
    hintLSI: {
      cs: ''
    }
  },
    {
      src: '../../data/examples/exampleUU5LayoutFlcMixin02.html',
      descLSI: {
        en: `ToDo!!!`,
        cs: `Příklad zobrazuje vlastní komponentu <UU5.Bricks.Code content='UU5.Example.MyFlc'/>, na které
jsou použity metody rozhraní. Tato komponenta je zabalená do dalších komponent -
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.Column' />,
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.Row' /> a
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.Container' />.

Metody <UU5.Bricks.Code content='getContainer()'/> a <UU5.Bricks.Code content='getRow()'/> v tomto příkladu vrací objekt - nadřazenou komponentu <UU5.Bricks.Code content='UU5.Layout.Container'/> a <UU5.Bricks.Code content='UU5.Layout.Row'/>.
Aby byl tento příklad názornější, na objektu je zavolána ještě metoda <UU5.Bricks.Code content='getId()' />, která vrátí ID komponenty <UU5.Bricks.Code content='row' />.

Metoda <UU5.Bricks.Code content='getRowIndex()' />, <UU5.Bricks.Code content='getContainerIndex()' /> vrátí index nadřazených komponent (pořadí).
Např. v příkladu jsou dvě komponenty <UU5.Bricks.Code content='UU5.Layout.Row' />. Metoda <UU5.Bricks.Code content='getRowIndex()' /> vrátí <UU5.Bricks.Code content='1' />, protože nadřazená <UU5.Bricks.Code content='row'/> komponenty <UU5.Bricks.Code content='UU5.Example.MyFlc' /> je v pořadí druhá (má index 1).

Metody <UU5.Bricks.Code content='getRowCollection()' /> a <UU5.Bricks.Code content='getContainerCollection()' /> vrátí <UU5.Bricks.Code content='null' />, protože vlastní komponenta <UU5.Bricks.Code content='UU5.Example.MyFlc' /> nemá žádnou nadřazenou komponentu, která by splňovala <UU5.DocKit.Bricks.Link tagName='RowCollectionMixin'/>, <UU5.DocKit.Bricks.Link tagName='ContainerCollectionMixin'/>.`
      },
      hintLSI: {
        cs: ''
      }
    },
    {
      src: '../../data/examples/exampleUU5LayoutFlcMixin03.html',
      descLSI: {
        en: `ToDo!!!`,
        cs: `Příklad použití metod rozhraní <UU5.Bricks.Code content='UU5.Layout.FlcMixin'/>. Metoda <UU5.Bricks.Code content='hasUU5_Layout_FlcMixin()' />
zkontroluje, jestli komponenta splňuje <UU5.Bricks.Code content="UU5.Layout.FlcMixin" />. Metody <UU5.Bricks.Code content='getColumnCollection()' />
a <UU5.Bricks.Code content='getWrapperCollection()' /> vrací v tomto příkladu <UU5.Bricks.Code content='null' />, protože komponenty
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.WrapperCollection' /> a
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.ColumnCollection' />
nejsou v příkladu použity. Metoda <UU5.Bricks.Code content='getWrapperIndex()' /> vrátí index nadřazené komponenty
<UU5.DocKit.Bricks.Link tagName='UU5.Layout.Wrapper' /> a metody
<UU5.Bricks.Code content='getWrapper()' /> a <UU5.Bricks.Code content='getColumn()' /> vrátí nadřazenou komponentu.`
      },
      hintLSI: {
        cs: ''
      }
    }
  ]
};


text:
using ApiTemplate.Api.Application.Features.MasterFiles;
using ApiTemplate.Api.Domain.Model.MasterFiles;

namespace ApiTemplate.Api.Controllers.MasterFiles
{
    public class DisposalReasonController : MasterFileControllerFor<DisposalReason, DisposalReasonDto> { }
    public class WeatherTypeController : MasterFileControllerFor<WeatherType, WeatherTypeDto> { }
}


text:
describe("", function() {
  var rootEl;
  beforeEach(function() {
    rootEl = browser.rootEl;
    browser.get("build/docs/examples/example-example58/ratingList.html");
  });

it('should toggle open', function() {
  expect(element(by.id('details')).getAttribute('open')).toBeFalsy();
  element(by.model('open')).click();
  expect(element(by.id('details')).getAttribute('open')).toBeTruthy();
});
});


text:
# isFunction

> Test if a value is a function.

## Usage

```javascript
var isFunction = require( '@stdlib/assert/is-function' );
```

#### isFunction( value )

Tests if a `value` is a `function`.

```javascript
function beep() {
    console.log( 'beep' );
}

var bool = isFunction( beep );
// returns true
```

## Examples

```javascript
var isFunction = require( '@stdlib/assert/is-function' );

var bool = isFunction( function foo() {} );
// returns true

bool = isFunction( 'beep' );
// returns false

bool = isFunction( 5 );
// returns false

bool = isFunction( true );
// returns false

bool = isFunction( null );
// returns false

bool = isFunction( [] );
// returns false

bool = isFunction( {} );
// returns false
```


text:
import pygame
import numpy  # import is unused but required or we fail later
from pygame.constants import K_DOWN, K_UP, KEYDOWN, KEYUP, QUIT
import pygame.surfarray
import pygame.key

def function_intercept(intercepted_func, intercepting_func):
    """
    Intercepts a method call and calls the supplied intercepting_func with the result of it's call and it's arguments

    Example:
        def get_event(result_of_real_event_get, *args, **kwargs):
            # do work
            return result_of_real_event_get

        pygame.event.get = function_intercept(pygame.event.get, get_event)

    :param intercepted_func: The function we are going to intercept
    :param intercepting_func:   The function that will get called after the intercepted func. It is supplied the return
    value of the intercepted_func as the first argument and it's args and kwargs.
    :return: a function that combines the intercepting and intercepted function, should normally be set to the
             intercepted_functions location
    """

    def wrap(*args, **kwargs):
        real_results = intercepted_func(*args, **kwargs)  # call the function we are intercepting and get it's result
        intercepted_results = intercepting_func(real_results, *args, **kwargs)  # call our own function a
        return intercepted_results

    return wrap

class PyGamePlayer(object):
    def __init__(self, force_game_fps=10, run_real_time=False, pass_quit_event=True):
        """
        Abstract class for learning agents, such as running reinforcement learning neural nets against PyGame games.

        The get_keys_pressed and get_feedback methods must be overriden by a subclass to use

        Call start method to start playing intercepting PyGame and training our machine
        :param force_game_fps: Fixes the pygame timer functions so the ai will get input as if it were running at this
                               fps
        :type force_game_fps: int
        :param run_real_time: If True the game will actually run at the force_game_fps speed
        :type run_real_time: bool
        :param pass_quit_event: If True the ai will be asked for the quit event
        :type pass_quit_event: bool
        """
        self.force_game_fps = force_game_fps
        """Fixes the pygame timer functions so the ai will get input as if it were running at this fps"""
        self.run_real_time = run_real_time
        """If True the game will actually run at the force_game_fps speed"""
        self.pass_quit_event = pass_quit_event
        """Decides whether the quit event should be passed on to the game"""
        self._keys_pressed = []
        self._last_keys_pressed = []
        self._playing = False
        self._default_flip = pygame.display.flip
        self._default_update = pygame.display.update
        self._default_event_get = pygame.event.get
        self._default_time_clock = pygame.time.Clock
        self._default_get_ticks = pygame.time.get_ticks
        self._game_time = 0.0

    def get_keys_pressed(self, screen_array, feedback, terminal):
        """
        Called whenever the screen buffer is refreshed. returns the keys we want pressed in the next until the next
        screen refresh

        :param screen_array: 3d numpy.array of float. screen_width * screen_height * rgb
        :param feedback: result of call to get_feedback
        :param terminal: boolean, True if we have reached a terminal state, meaning the next frame will be a restart
        :return: a list of the integer values of the keys we want pressed. See pygame.constants for values
        """
        raise NotImplementedError("Please override this method")

    def get_feedback(self):
        """
        Overriden method should hook into game events to give feeback to the learning agent

        :return: First = value we want to give as reward/punishment to our learning agent
                 Second = Boolean true if we have reached a terminal state
        :rtype: tuple (float, boolean)
        """
        raise NotImplementedError("Please override this method")

    def start(self):
        """
        Start playing the game. We will now start listening for screen updates calling our play and reward functions
        and returning our intercepted key presses
        """
        if self._playing:
            raise Exception("Already playing")

        pygame.display.flip = function_intercept(pygame.display.flip, self._on_screen_update)
        pygame.display.update = function_intercept(pygame.display.update, self._on_screen_update)
        pygame.event.get = function_intercept(pygame.event.get, self._on_event_get)
        pygame.time.Clock = function_intercept(pygame.time.Clock, self._on_time_clock)
        pygame.time.get_ticks = function_intercept(pygame.time.get_ticks, self.get_game_time_ms)
        # TODO: handle pygame.time.set_timer...

        self._playing = True

    def stop(self):
        """
        Stop playing the game. Will try and return PyGame to the state it was in before we started
        """
        if not self._playing:
            raise Exception("Already stopped")

        pygame.display.flip = self._default_flip
        pygame.display.update = self._default_update
        pygame.event.get = self._default_event_get
        pygame.time.Clock = self._default_time_clock
        pygame.time.get_ticks = self._default_get_ticks

        self._playing = False

    @property
    def playing(self):
        """
        Returns if we are in a state where we are playing/intercepting PyGame calls
        :return: boolean
        """
        return self._playing

    @playing.setter
    def playing(self, value):
        if self._playing == value:
            return
        if self._playing:
            self.stop()
        else:
            self.start()

    def get_ms_per_frame(self):
        return 1000.0 / self.force_game_fps

    def get_game_time_ms(self):
        return self._game_time

    def _on_time_clock(self, real_clock, *args, **kwargs):
        return self._FixedFPSClock(self, real_clock)

    def _on_screen_update(self, _, *args, **kwargs):
        surface_array = pygame.surfarray.array3d(pygame.display.get_surface())
        reward, terminal = self.get_feedback()
        keys = self.get_keys_pressed(surface_array, reward, terminal)
        self._last_keys_pressed = self._keys_pressed
        self._keys_pressed = keys

        # now we have processed a frame increment the game timer
        self._game_time += self.get_ms_per_frame()

    def _on_event_get(self, _, *args, **kwargs):
        key_up_events = []
        if len(self._last_keys_pressed) > 0:
            diff_list = list(set( self._last_keys_pressed) - set(self._keys_pressed))
            key_up_events = [pygame.event.Event(KEYUP, {"key": x}) for x in diff_list]

        key_down_events = [pygame.event.Event(KEYDOWN, {"key": x}) for x in self._keys_pressed]

        result = []

        # have to deal with arg type filters
        if args:
            if hasattr(args[0], "__iter__"):
                args = args[0]

            for type_filter in args:
                if type_filter == QUIT:
                    if type_filter == QUIT:
                        if self.pass_quit_event:
                            for e in _:
                                if e.type == QUIT:
                                    result.append(e)
                    else:
                        pass  # never quit
                elif type_filter == KEYUP:
                    result = result + key_up_events
                elif type_filter == KEYDOWN:
                    result = result + key_down_events
        else:
            result = key_down_events + key_up_events
            if self.pass_quit_event:
                for e in _:
                    if e.type == QUIT:
                        result.append(e)

        return result

    def __enter__(self):
        self.start()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.stop()

    class _FixedFPSClock(object):
        def __init__(self, pygame_player, real_clock):
            self._pygame_player = pygame_player
            self._real_clock = real_clock

        def tick(self, _=None):
            if self._pygame_player.run_real_time:
                return self._real_clock.tick(self._pygame_player.force_game_fps)
            else:
                return self._pygame_player.get_ms_per_frame()

        def tick_busy_loop(self, _=None):
            if self._pygame_player.run_real_time:
                return self._real_clock.tick_busy_loop(self._pygame_player.force_game_fps)
            else:
                return self._pygame_player.get_ms_per_frame()

        def get_time(self):
            return self._pygame_player.get_game_time_ms()

        def get_raw_time(self):
            return self._pygame_player.get_game_time_ms()

        def get_fps(self):
            return int(1.0 / self._pygame_player.get_ms_per_frame())


text:
input="sszojmmrrkwuftyv
isaljhemltsdzlum
fujcyucsrxgatisb
qiqqlmcgnhzparyg
oijbmduquhfactbc
jqzuvtggpdqcekgk
zwqadogmpjmmxijf
uilzxjythsqhwndh
gtssqejjknzkkpvw
wrggegukhhatygfi
vhtcgqzerxonhsye
tedlwzdjfppbmtdx
iuvrelxiapllaxbg
feybgiimfthtplui
qxmmcnirvkzfrjwd
vfarmltinsriqxpu
oanqfyqirkraesfq
xilodxfuxphuiiii
yukhnchvjkfwcbiq
bdaibcbzeuxqplop
ivegnnpbiyxqsion
ybahkbzpditgwdgt
dmebdomwabxgtctu
ibtvimgfaeonknoh
jsqraroxudetmfyw
dqdbcwtpintfcvuz
tiyphjunlxddenpj
fgqwjgntxagidhah
nwenhxmakxqkeehg
zdoheaxqpcnlhnen
tfetfqojqcdzlpbm
qpnxkuldeiituggg
xwttlbdwxohahwar
hjkwzadmtrkegzye
koksqrqcfwcaxeof
wulwmrptktliyxeq
gyufbedqhhyqgqzj
txpunzodohikzlmj
jloqfuejfkemcrvu
amnflshcheuddqtc
pdvcsduggcogbiia
yrioavgfmeafjpcz
uyhbtmbutozzqfvq
mwhgfwsgyuwcdzik
auqylgxhmullxpaa
lgelzivplaeoivzh
uyvcepielfcmswoa
qhirixgwkkccuzlp
zoonniyosmkeejfg
iayfetpixkedyana
ictqeyzyqswdskiy
ejsgqteafvmorwxe
lhaiqrlqqwfbrqdx
ydjyboqwhfpqfydc
dwhttezyanrnbybv
edgzkqeqkyojowvr
rmjfdwsqamjqehdq
ozminkgnkwqctrxz
bztjhxpjthchhfcd
vrtioawyxkivrpiq
dpbcsznkpkaaclyy
vpoypksymdwttpvz
hhdlruwclartkyap
bqkrcbrksbzcggbo
jerbbbnxlwfvlaiw
dwkasufidwjrjfbf
kkfxtjhbnmqbmfwf
vmnfziwqxmioukmj
rqxvcultipkecdtu
fhmfdibhtjzkiqsd
hdpjbuzzbyafqrpd
emszboysjuvwwvts
msyigmwcuybfiooq
druyksfnbluvnwoh
fvgstvynnfbvxhsx
bmzalvducnqtuune
lzwkzfzttsvpllei
olmplpvjamynfyfd
padcwfkhystsvyfb
wjhbvxkwtbfqdilb
hruaqjwphonnterf
bufjobjtvxtzjpmj
oiedrjvmlbtwyyuy
sgiemafwfztwsyju
nsoqqfudrtwszyqf
vonbxquiiwxnazyl
yvnmjxtptujwqudn
rrnybqhvrcgwvrkq
taktoxzgotzxntfu
quffzywzpxyaepxa
rfvjebfiddcfgmwv
iaeozntougqwnzoh
scdqyrhoqmljhoil
bfmqticltmfhxwld
brbuktbyqlyfpsdl
oidnyhjkeqenjlhd
kujsaiqojopvrygg
vebzobmdbzvjnjtk
uunoygzqjopwgmbg
piljqxgicjzgifso
ikgptwcjzywswqnw
pujqsixoisvhdvwi
trtuxbgigogfsbbk
mplstsqclhhdyaqk
gzcwflvmstogdpvo
tfjywbkmimyyqcjd
gijutvhruqcsiznq
ibxkhjvzzxgavkha
btnxeqvznkxjsgmq
tjgofgauxaelmjoq
sokshvyhlkxerjrv
ltogbivktqmtezta
uduwytzvqvfluyuf
msuckpthtgzhdxan
fqmcglidvhvpirzr
gwztkqpcwnutvfga
bsjfgsrntdhlpqbx
xloczbqybxmiopwt
orvevzyjliomkkgu
mzjbhmfjjvaziget
tlsdxuhwdmghdyjb
atoecyjhwmznaewi
pyxpyvvipbqibiox
ajbfmpqqobfsmesj
siknbzefjblnohgd
eqfhgewbblwdfkmc
opylbscrotckkrbk
lbwxbofgjkzdxkle
ceixfjstaptdomvm
hnkrqxifjmmjktie
aqykzeuzvvetoygd
fouahjimfcisxima
prkzhutbqsyrhjzx
qqwliakathnsbzne
sayhgqtlcqqidqhj
ygduolbysehdudra
zricvxhdzznuxuce
ucvzakslykpgsixd
udirhgcttmyspgsb
yuwzppjzfsjhhdzi
gtqergjiuwookwre
xvxexbjyjkxovvwf
mlpaqhnnkqxrmwmm
ezuqbrjozwuqafhb
mcarusdthcbsonoq
weeguqeheeiigrue
pngtfugozxofaqxv
copphvbjcmfspenv
jiyahihykjjkdaya
gdqnmesvptuyrfwp
vbdscfywqmfxbohh
crtrfuxyjypzubrg
seihvevtxywxhflp
fvvpmgttnapklwou
qmqaqsajmqwhetpk
zetxvrgjmblxvakr
kpvwblrizaabmnhz
mwpvvzaaicntrkcp
clqyjiegtdsswqfm
ymrcnqgcpldgfwtm
nzyqpdenetncgnwq
cmkzevgacnmdkqro
kzfdsnamjqbeirhi
kpxrvgvvxapqlued
rzskbnfobevzrtqu
vjoahbfwtydugzap
ykbbldkoijlvicbl
mfdmroiztsgjlasb
quoigfyxwtwprmdr
ekxjqafwudgwfqjm
obtvyjkiycxfcdpb
lhoihfnbuqelthof
eydwzitgxryktddt
rxsihfybacnpoyny
bsncccxlplqgygtw
rvmlaudsifnzhcqh
huxwsyjyebckcsnn
gtuqzyihwhqvjtes
zreeyomtngvztveq
nwddzjingsarhkxb
nuqxqtctpoldrlsh
wkvnrwqgjooovhpf
kwgueyiyffudtbyg
tpkzapnjxefqnmew
ludwccvkihagvxal
lfdtzhfadvabghna
njqmlsnrkcfhtvbb
cajzbqleghhnlgap
vmitdcozzvqvzatp
eelzefwqwjiywbcz
uyztcuptfqvymjpi
aorhnrpkjqqtgnfo
lfrxfdrduoeqmwwp
vszpjvbctblplinh
zexhadgpqfifcqrz
ueirfnshekpemqua
qfremlntihbwabtb
nwznunammfexltjc
zkyieokaaogjehwt
vlrxgkpclzeslqkq
xrqrwfsuacywczhs
olghlnfjdiwgdbqc
difnlxnedpqcsrdf
dgpuhiisybjpidsj
vlwmwrikmitmoxbt
sazpcmcnviynoktm
pratafauetiknhln
ilgteekhzwlsfwcn
ywvwhrwhkaubvkbl
qlaxivzwxyhvrxcf
hbtlwjdriizqvjfb
nrmsononytuwslsa
mpxqgdthpoipyhjc
mcdiwmiqeidwcglk
vfbaeavmjjemfrmo
qzcbzmisnynzibrc
shzmpgxhehhcejhb
wirtjadsqzydtyxd
qjlrnjfokkqvnpue
dxawdvjntlbxtuqc
wttfmnrievfestog
eamjfvsjhvzzaobg
pbvfcwzjgxahlrag
omvmjkqqnobvnzkn
lcwmeibxhhlxnkzv
uiaeroqfbvlazegs
twniyldyuonfyzqw
wgjkmsbwgfotdabi
hnomamxoxvrzvtew
ycrcfavikkrxxfgw
isieyodknagzhaxy
mgzdqwikzullzyco
mumezgtxjrrejtrs
nwmwjcgrqiwgfqel
wjgxmebfmyjnxyyp
durpspyljdykvzxf
zuslbrpooyetgafh
kuzrhcjwbdouhyme
wyxuvbciodscbvfm
kbnpvuqwmxwfqtqe
zddzercqogdpxmft
sigrdchxtgavzzjh
lznjolnorbuddgcs
ycnqabxlcajagwbt
bnaudeaexahdgxsj
rlnykxvoctfwanms
jngyetkoplrstfzt
tdpxknwacksotdub
yutqgssfoptvizgr
lzmqnxeqjfnsxmsa
iqpgfsfmukovsdgu
qywreehbidowtjyz
iozamtgusdctvnkw
ielmujhtmynlwcfd
hzxnhtbnmmejlkyf
ftbslbzmiqkzebtd
bcwdqgiiizmohack
dqhfkzeddjzbdlxu
mxopokqffisxosci
vciatxhtuechbylk
khtkhcvelidjdena
blatarwzfqcapkdt
elamngegnczctcck
xeicefdbwrxhuxuf
sawvdhjoeahlgcdr
kmdcimzsfkdfpnir
axjayzqlosrduajb
mfhzreuzzumvoggr
iqlbkbhrkptquldb
xcvztvlshiefuhgb
pkvwyqmyoazocrio
ajsxkdnerbmhyxaj
tudibgsbnpnizvsi
cxuiydkgdccrqvkh
cyztpjesdzmbcpot
nnazphxpanegwitx
uphymczbmjalmsct
yyxiwnlrogyzwqmg
gmqwnahjvvdyhnfa
utolskxpuoheugyl
mseszdhyzoyavepd
ycqknvbuvcjfgmlc
sknrxhxbfpvpeorn
zqxqjetooqcodwml
sesylkpvbndrdhsy
fryuxvjnsvnjrxlw
mfxusewqurscujnu
mbitdjjtgzchvkfv
ozwlyxtaalxofovd
wdqcduaykxbunpie
rlnhykxiraileysk
wgoqfrygttlamobg
kflxzgxvcblkpsbz
tmkisflhativzhde
owsdrfgkaamogjzd
gaupjkvkzavhfnes
wknkurddcknbdleg
lltviwincmbtduap
qwzvspgbcksyzzmb
ydzzkumecryfjgnk
jzvmwgjutxoysaam
icrwpyhxllbardkr
jdopyntshmvltrve
afgkigxcuvmdbqou
mfzzudntmvuyhjzt
duxhgtwafcgrpihc
tsnhrkvponudumeb
sqtvnbeiigdzbjgv
eczmkqwvnsrracuo
mhehsgqwiczaiaxv
kaudmfvifovrimpd
lupikgivechdbwfr
mwaaysrndiutuiqx
aacuiiwgaannunmm
tjqjbftaqitukwzp
lrcqyskykbjpaekn
lirrvofbcqpjzxmr
jurorvzpplyelfml
qonbllojmloykjqe
sllkzqujfnbauuqp
auexjwsvphvikali
usuelbssqmbrkxyc
wyuokkfjexikptvv
wmfedauwjgbrgytl
sfwvtlzzebxzmuvw
rdhqxuechjsjcvaf
kpavhqkukugocsxu
ovnjtumxowbxduts
zgerpjufauptxgat
pevvnzjfwhjxdoxq
pmmfwxajgfziszcs
difmeqvaghuitjhs
icpwjbzcmlcterwm
ngqpvhajttxuegyh
mosjlqswdngwqsmi
frlvgpxrjolgodlu
eazwgrpcxjgoszeg
bbtsthgkjrpkiiyk
tjonoglufuvsvabe
xhkbcrofytmbzrtk
kqftfzdmpbxjynps
kmeqpocbnikdtfyv
qjjymgqxhnjwxxhp
dmgicrhgbngdtmjt
zdxrhdhbdutlawnc
afvoekuhdboxghvx
hiipezngkqcnihty
bbmqgheidenweeov
suprgwxgxwfsgjnx
adeagikyamgqphrj
zzifqinoeqaorjxg
adhgppljizpaxzld
lvxyieypvvuqjiyc
nljoakatwwwoovzn
fcrkfxclcacshhmx
ownnxqtdhqbgthch
lmfylrcdmdkgpwnj
hlwjfbvlswbzpbjr
mkofhdtljdetcyvp
synyxhifbetzarpo
agnggugngadrcxoc
uhttadmdmhidpyjw
ohfwjfhunalbubpr
pzkkkkwrlvxiuysn
kmidbxmyzkjrwjhu
egtitdydwjxmajnw
civoeoiuwtwgbqqs
dfptsguzfinqoslk
tdfvkreormspprer
zvnvbrmthatzztwi
ffkyddccrrfikjde
hrrmraevdnztiwff
qaeygykcpbtjwjbr
purwhitkmrtybslh
qzziznlswjaussel
dfcxkvdpqccdqqxj
tuotforulrrytgyn
gmtgfofgucjywkev
wkyoxudvdkbgpwhd
qbvktvfvipftztnn
otckgmojziezmojb
inxhvzbtgkjxflay
qvxapbiatuudseno
krpvqosbesnjntut
oqeukkgjsfuqkjbb
prcjnyymnqwqksiz
vuortvjxgckresko
orqlyobvkuwgathr
qnpyxlnazyfuijox
zwlblfkoklqmqzkw
hmwurwtpwnrcsanl
jzvxohuakopuzgpf
sfcpnxrviphhvxmx
qtwdeadudtqhbely
dbmkmloasqphnlgj
olylnjtkxgrubmtk
nxsdbqjuvwrrdbpq
wbabpirnpcsmpipw
hjnkyiuxpqrlvims
enzpntcjnxdpuqch
vvvqhlstzcizyimn
triozhqndbttglhv
fukvgteitwaagpzx
uhcvukfbmrvskpen
tizcyupztftzxdmt
vtkpnbpdzsaluczz
wodfoyhoekidxttm
otqocljrmwfqbxzu
linfbsnfvixlwykn
vxsluutrwskslnye
zbshygtwugixjvsi
zdcqwxvwytmzhvoo
wrseozkkcyctrmei
fblgtvogvkpqzxiy
opueqnuyngegbtnf
qxbovietpacqqxok
zacrdrrkohfygddn
gbnnvjqmkdupwzpq
qgrgmsxeotozvcak
hnppukzvzfmlokid
dzbheurndscrrtcl
wbgdkadtszebbrcw
fdmzppzphhpzyuiz
bukomunhrjrypohj
ohodhelegxootqbj
rsplgzarlrknqjyh
punjjwpsxnhpzgvu
djdfahypfjvpvibm
mlgrqsmhaozatsvy
xwktrgyuhqiquxgn
wvfaoolwtkbrisvf
plttjdmguxjwmeqr
zlvvbwvlhauyjykw
cigwkbyjhmepikej
masmylenrusgtyxs
hviqzufwyetyznze
nzqfuhrooswxxhus
pdbdetaqcrqzzwxf
oehmvziiqwkzhzib
icgpyrukiokmytoy
ooixfvwtiafnwkce
rvnmgqggpjopkihs
wywualssrmaqigqk
pdbvflnwfswsrirl
jeaezptokkccpbuj
mbdwjntysntsaaby
ldlgcawkzcwuxzpz
lwktbgrzswbsweht
ecspepmzarzmgpjm
qmfyvulkmkxjncai
izftypvwngiukrns
zgmnyjfeqffbooww
nyrkhggnprhedows
yykzzrjmlevgffah
mavaemfxhlfejfki
cmegmfjbkvpncqwf
zxidlodrezztcrij
fseasudpgvgnysjv
fupcimjupywzpqzp
iqhgokavirrcvyys
wjmkcareucnmfhui
nftflsqnkgjaexhq
mgklahzlcbapntgw
kfbmeavfxtppnrxn
nuhyvhknlufdynvn
nviogjxbluwrcoec
tyozixxxaqiuvoys
kgwlvmvgtsvxojpr
moeektyhyonfdhrb
kahvevmmfsmiiqex
xcywnqzcdqtvhiwd
fnievhiyltbvtvem
jlmndqufirwgtdxd
muypbfttoeelsnbs
rypxzbnujitfwkou
ubmmjbznskildeoj
ofnmizdeicrmkjxp
rekvectjbmdnfcib
yohrojuvdexbctdh
gwfnfdeibynzjmhz
jfznhfcqdwlpjull
scrinzycfhwkmmso
mskutzossrwoqqsi
rygoebkzgyzushhr
jpjqiycflqkexemx
arbufysjqmgaapnl
dbjerflevtgweeoj
snybnnjlmwjvhois
fszuzplntraprmbj
mkvaatolvuggikvg
zpuzuqygoxesnuyc
wnpxvmxvllxalulm
eivuuafkvudeouwy
rvzckdyixetfuehr
qgmnicdoqhveahyx
miawwngyymshjmpj
pvckyoncpqeqkbmx
llninfenrfjqxurv
kzbjnlgsqjfuzqtp
rveqcmxomvpjcwte
bzotkawzbopkosnx
ktqvpiribpypaymu
wvlzkivbukhnvram
uohntlcoguvjqqdo
ajlsiksjrcnzepkt
xsqatbldqcykwusd
ihbivgzrwpmowkop
vfayesfojmibkjpb
uaqbnijtrhvqxjtb
hhovshsfmvkvymba
jerwmyxrfeyvxcgg
hncafjwrlvdcupma
qyvigggxfylbbrzt
hiiixcyohmvnkpgk
mmitpwopgxuftdfu
iaxderqpceboixoa
zodfmjhuzhnsqfcb
sthtcbadrclrazsi
bkkkkcwegvypbrio
wmpcofuvzemunlhj
gqwebiifvqoeynro
juupusqdsvxcpsgv
rbhdfhthxelolyse
kjimpwnjfrqlqhhz
rcuigrjzarzpjgfq
htxcejfyzhydinks
sxucpdxhvqjxxjwf
omsznfcimbcwaxal
gufmtdlhgrsvcosb
bssshaqujtmluerz
uukotwjkstgwijtr
kbqkneobbrdogrxk
ljqopjcjmelgrakz
rwtfnvnzryujwkfb
dedjjbrndqnilbeh
nzinsxnpptzagwlb
lwqanydfirhnhkxy
hrjuzfumbvfccxno
okismsadkbseumnp
sfkmiaiwlktxqvwa
hauwpjjwowbunbjj
nowkofejwvutcnui
bqzzppwoslaeixro
urpfgufwbtzenkpj
xgeszvuqwxeykhef
yxoldvkyuikwqyeq
onbbhxrnmohzskgg
qcikuxakrqeugpoa
lnudcqbtyzhlpers
nxduvwfrgzaailgl
xniuwvxufzxjjrwz
ljwithcqmgvntjdj
awkftfagrfzywkhs
uedtpzxyubeveuek
bhcqdwidbjkqqhzl
iyneqjdmlhowwzxx
kvshzltcrrururty
zgfpiwajegwezupo
tkrvyanujjwmyyri
ercsefuihcmoaiep
ienjrxpmetinvbos
jnwfutjbgenlipzq
bgohjmrptfuamzbz
rtsyamajrhxbcncw
tfjdssnmztvbnscs
bgaychdlmchngqlp
kfjljiobynhwfkjo
owtdxzcpqleftbvn
ltjtimxwstvzwzjj
wbrvjjjajuombokf
zblpbpuaqbkvsxye
gwgdtbpnlhyqspdi
abipqjihjqfofmkx
nlqymnuvjpvvgova
avngotmhodpoufzn
qmdyivtzitnrjuae
xfwjmqtqdljuerxi
csuellnlcyqaaamq
slqyrcurcyuoxquo
dcjmxyzbzpohzprl
uqfnmjwniyqgsowb
rbmxpqoblyxdocqc
ebjclrdbqjhladem
ainnfhxnsgwqnmyo
eyytjjwhvodtzquf
iabjgmbbhilrcyyp
pqfnehkivuelyccc
xgjbyhfgmtseiimt
jwxyqhdbjiqqqeyy
gxsbrncqkmvaryln
vhjisxjkinaejytk
seexagcdmaedpcvh
lvudfgrcpjxzdpvd
fxtegyrqjzhmqean
dnoiseraqcoossmc
nwrhmwwbykvwmgep
udmzskejvizmtlce
hbzvqhvudfdlegaa
cghmlfqejbxewskv
bntcmjqfwomtbwsb
qezhowyopjdyhzng
todzsocdkgfxanbz
zgjkssrjlwxuhwbk
eibzljqsieriyrzr
wamxvzqyycrxotjp
epzvfkispwqynadu
dwlpfhtrafrxlyie
qhgzujhgdruowoug
girstvkahaemmxvh
baitcrqmxhazyhbl
xyanqcchbhkajdmc
gfvjmmcgfhvgnfdq
tdfdbslwncbnkzyz
jojuselkpmnnbcbb
hatdslkgxtqpmavj
dvelfeddvgjcyxkj
gnsofhkfepgwltse
mdngnobasfpewlno
qssnbcyjgmkyuoga
glvcmmjytmprqwvn
gwrixumjbcdffsdl
lozravlzvfqtsuiq
sicaflbqdxbmdlch
inwfjkyyqbwpmqlq
cuvszfotxywuzhzi
igfxyoaacoarlvay
ucjfhgdmnjvgvuni
rvvkzjsytqgiposh
jduinhjjntrmqroz
yparkxbgsfnueyll
lyeqqeisxzfsqzuj
woncskbibjnumydm
lltucklragtjmxtl
ubiyvmyhlesfxotj
uecjseeicldqrqww
xxlxkbcthufnjbnm
lhqijovvhlffpxga
fzdgqpzijitlogjz
efzzjqvwphomxdpd
jvgzvuyzobeazssc
hejfycgxywfjgbfw
yhjjmvkqfbnbliks
sffvfyywtlntsdsz
dwmxqudvxqdenrur
asnukgppdemxrzaz
nwqfnumblwvdpphx
kqsmkkspqvxzuket
cpnraovljzqiquaz
qrzgrdlyyzbyykhg
opoahcbiydyhsmqe
hjknnfdauidjeydr
hczdjjlygoezadow
rtflowzqycimllfv
sfsrgrerzlnychhq
bpahuvlblcolpjmj
albgnjkgmcrlaicl
pijyqdhfxpaxzdex
eeymiddvcwkpbpux
rqwkqoabywgggnln
vckbollyhgbgmgwh
ylzlgvnuvpynybkm
hpmbxtpfosbsjixt
ocebeihnhvkhjfqz
tvctyxoujdgwayze
efvhwxtuhapqxjen
rusksgefyidldmpo
nkmtjvddfmhirmzz
whvtsuadwofzmvrt
iiwjqvsdxudhdzzk
gucirgxaxgcassyo
rmhfasfzexeykwmr
hynlxcvsbgosjbis
huregszrcaocueen
pifezpoolrnbdqtv
unatnixzvdbqeyox
xtawlpduxgacchfe
bdvdbflqfphndduf
xtdsnjnmzccfptyt
nkhsdkhqtzqbphhg
aqcubmfkczlaxiyb
moziflxpsfubucmv
srdgnnjtfehiimqx
pwfalehdfyykrohf
sysxssmvewyfjrve
brsemdzosgqvvlxe
bimbjoshuvflkiat
hkgjasmljkpkwwku
sbnmwjvodygobpqc
bbbqycejueruihhd
corawswvlvneipyc
gcyhknmwsczcxedh
kppakbffdhntmcqp
ynulzwkfaemkcefp
pyroowjekeurlbii
iwksighrswdcnmxf
glokrdmugreygnsg
xkmvvumnfzckryop
aesviofpufygschi
csloawlirnegsssq
fkqdqqmlzuxbkzbc
uzlhzcfenxdfjdzp
poaaidrktteusvyf
zrlyfzmjzfvivcfr
qwjulskbniitgqtx
gjeszjksbfsuejki
vczdejdbfixbduaq
knjdrjthitjxluth
jweydeginrnicirl
bottrfgccqhyycsl
eiquffofoadmbuhk
lbqfutmzoksscswf
xfmdvnvfcnzjprba
uvugkjbkhlaoxmyx
wadlgtpczgvcaqqv
inzrszbtossflsxk
dbzbtashaartczrj
qbjiqpccefcfkvod
hluujmokjywotvzy
thwlliksfztcmwzh
arahybspdaqdexrq
nuojrmsgyipdvwyx
hnajdwjwmzattvst
sulcgaxezkprjbgu
rjowuugwdpkjtypw
oeugzwuhnrgiaqga
wvxnyymwftfoswij
pqxklzkjpcqscvde
tuymjzknntekglqj
odteewktugcwlhln
exsptotlfecmgehc
eeswfcijtvzgrqel
vjhrkiwmunuiwqau
zhlixepkeijoemne
pavfsmwesuvebzdd
jzovbklnngfdmyws
nbajyohtzfeoiixz
ciozmhrsjzrwxvhz
gwucrxieqbaqfjuv
uayrxrltnohexawc
flmrbhwsfbcquffm
gjyabmngkitawlxc
rwwtggvaygfbovhg
xquiegaisynictjq
oudzwuhexrwwdbyy
lengxmguyrwhrebb
uklxpglldbgqsjls
dbmvlfeyguydfsxq
zspdwdqcrmtmdtsc
mqfnzwbfqlauvrgc
amcrkzptgacywvhv
ndxmskrwrqysrndf
mwjyhsufeqhwisju
srlrukoaenyevykt
tnpjtpwawrxbikct
geczalxmgxejulcv
tvkcbqdhmuwcxqci
tiovluvwezwwgaox
zrjhtbgajkjqzmfo
vcrywduwsklepirs
lofequdigsszuioy
wxsdzomkjqymlzat
iabaczqtrfbmypuy
ibdlmudbajikcncr
rqcvkzsbwmavdwnv
ypxoyjelhllhbeog
fdnszbkezyjbttbg
uxnhrldastpdjkdz
xfrjbehtxnlyzcka
omjyfhbibqwgcpbv
eguucnoxaoprszmp
xfpypldgcmcllyzz
aypnmgqjxjqceelv
mgzharymejlafvgf
tzowgwsubbaigdok
ilsehjqpcjwmylxc
pfmouwntfhfnmrwk
csgokybgdqwnduwp
eaxwvxvvwbrovypz
nmluqvobbbmdiwwb
lnkminvfjjzqbmio
mjiiqzycqdhfietz
towlrzriicyraevq
obiloewdvbrsfwjo
lmeooaajlthsfltw
ichygipzpykkesrw
gfysloxmqdsfskvt
saqzntehjldvwtsx
pqddoemaufpfcaew
mjrxvbvwcreaybwe
ngfbrwfqnxqosoai
nesyewxreiqvhald
kqhqdlquywotcyfy
liliptyoqujensfi
nsahsaxvaepzneqq
zaickulfjajhctye
gxjzahtgbgbabtht
koxbuopaqhlsyhrp
jhzejdjidqqtjnwe
dekrkdvprfqpcqki
linwlombdqtdeyop
dvckqqbnigdcmwmx
yaxygbjpzkvnnebv
rlzkdkgaagmcpxah
cfzuyxivtknirqvt
obivkajhsjnrxxhn
lmjhayymgpseuynn
bbjyewkwadaipyju
lmzyhwomfypoftuu
gtzhqlgltvatxack
jfflcfaqqkrrltgq
txoummmnzfrlrmcg
ohemsbfuqqpucups
imsfvowcbieotlok
tcnsnccdszxfcyde
qkcdtkwuaquajazz
arcfnhmdjezdbqku
srnocgyqrlcvlhkb
mppbzvfmcdirbyfw
xiuarktilpldwgwd
ypufwmhrvzqmexpc
itpdnsfkwgrdujmj
cmpxnodtsswkyxkr
wayyxtjklfrmvbfp
mfaxphcnjczhbbwy
sjxhgwdnqcofbdra
pnxmujuylqccjvjm
ivamtjbvairwjqwl
deijtmzgpfxrclss
bzkqcaqagsynlaer
tycefobvxcvwaulz
ctbhnywezxkdsswf
urrxxebxrthtjvib
fpfelcigwqwdjucv
ngfcyyqpqulwcphb
rltkzsiipkpzlgpw
qfdsymzwhqqdkykc
balrhhxipoqzmihj
rnwalxgigswxomga
ghqnxeogckshphgr
lyyaentdizaumnla
exriodwfzosbeoib
speswfggibijfejk
yxmxgfhvmshqszrq
hcqhngvahzgawjga
qmhlsrfpesmeksur
eviafjejygakodla
kvcfeiqhynqadbzv
fusvyhowslfzqttg
girqmvwmcvntrwau
yuavizroykfkdekz
jmcwohvmzvowrhxf
kzimlcpavapynfue
wjudcdtrewfabppq
yqpteuxqgbmqfgxh
xdgiszbuhdognniu
jsguxfwhpftlcjoh
whakkvspssgjzxre
ggvnvjurlyhhijgm
krvbhjybnpemeptr
pqedgfojyjybfbzr
jzhcrsgmnkwwtpdo
yyscxoxwofslncmp
gzjhnxytmyntzths
iteigbnqbtpvqumi
zjevfzusnjukqpfw
xippcyhkfuounxqk
mcnhrcfonfdgpkyh
pinkcyuhjkexbmzj
lotxrswlxbxlxufs
fmqajrtoabpckbnu
wfkwsgmcffdgaqxg
qfrsiwnohoyfbidr
czfqbsbmiuyusaqs
ieknnjeecucghpoo
cevdgqnugupvmsge
gjkajcyjnxdrtuvr
udzhrargnujxiclq
zqqrhhmjwermjssg
ggdivtmgoqajydzz
wnpfsgtxowkjiivl
afbhqawjbotxnqpd
xjpkifkhfjeqifdn
oyfggzsstfhvticp
kercaetahymeawxy
khphblhcgmbupmzt
iggoqtqpvaebtiol
ofknifysuasshoya
qxuewroccsbogrbv
apsbnbkiopopytgu
zyahfroovfjlythh
bxhjwfgeuxlviydq
uvbhdtvaypasaswa
qamcjzrmesqgqdiz
hjnjyzrxntiycyel
wkcrwqwniczwdxgq
hibxlvkqakusswkx
mzjyuenepwdgrkty
tvywsoqslfsulses
jqwcwuuisrclircv
xanwaoebfrzhurct
ykriratovsvxxasf
qyebvtqqxbjuuwuo
telrvlwvriylnder
acksrrptgnhkeiaa
yemwfjhiqlzsvdxf
banrornfkcymmkcc
ytbhxvaeiigjpcgm
crepyazgxquposkn
xlqwdrytzwnxzwzv
xtrbfbwopxscftps
kwbytzukgseeyjla
qtfdvavvjogybxjg
ytbmvmrcxwfkgvzw
nbscbdskdeocnfzr
sqquwjbdxsxhcseg
ewqxhigqcgszfsuw
cvkyfcyfmubzwsee
dcoawetekigxgygd
ohgqnqhfimyuqhvi
otisopzzpvnhctte
bauieohjejamzien
ewnnopzkujbvhwce
aeyqlskpaehagdiv
pncudvivwnnqspxy
ytugesilgveokxcg
zoidxeelqdjesxpr
ducjccsuaygfchzj
smhgllqqqcjfubfc
nlbyyywergronmir
prdawpbjhrzsbsvj
nmgzhnjhlpcplmui
eflaogtjghdjmxxz
qolvpngucbkprrdc
ixywxcienveltgho
mwnpqtocagenkxut
iskrfbwxonkguywx
ouhtbvcaczqzmpua
srewprgddfgmdbao
dyufrltacelchlvu
czmzcbrkecixuwzz
dtbeojcztzauofuk
prrgoehpqhngfgmw
baolzvfrrevxsyke
zqadgxshwiarkzwh
vsackherluvurqqj
surbpxdulvcvgjbd
wqxytarcxzgxhvtx
vbcubqvejcfsgrac
zqnjfeapshjowzja
hekvbhtainkvbynx
knnugxoktxpvoxnh
knoaalcefpgtvlwm
qoakaunowmsuvkus
ypkvlzcduzlezqcb
ujhcagawtyepyogh
wsilcrxncnffaxjf
gbbycjuscquaycrk
aduojapeaqwivnly
ceafyxrakviagcjy
nntajnghicgnrlst
vdodpeherjmmvbje
wyyhrnegblwvdobn
xlfurpghkpbzhhif
xyppnjiljvirmqjo
kglzqahipnddanpi
omjateouxikwxowr
ocifnoopfglmndcx
emudcukfbadyijev
ooktviixetfddfmh
wtvrhloyjewdeycg
cgjncqykgutfjhvb
nkwvpswppeffmwad
hqbcmfhzkxmnrivg
mdskbvzguxvieilr
anjcvqpavhdloaqh
erksespdevjylenq
fadxwbmisazyegup
iyuiffjmcaahowhj
ygkdezmynmltodbv
fytneukxqkjattvh
woerxfadbfrvdcnz
iwsljvkyfastccoa
movylhjranlorofe
drdmicdaiwukemep
knfgtsmuhfcvvshg
ibstpbevqmdlhajn
tstwsswswrxlzrqs
estyydmzothggudf
jezogwvymvikszwa
izmqcwdyggibliet
nzpxbegurwnwrnca
kzkojelnvkwfublh
xqcssgozuxfqtiwi
tcdoigumjrgvczfv
ikcjyubjmylkwlwq
kqfivwystpqzvhan
bzukgvyoqewniivj
iduapzclhhyfladn
fbpyzxdfmkrtfaeg
yzsmlbnftftgwadz"
vowel_list = ["a","e","i","o","u"]
nice = 1
nice_list = 0
vowels = 0
double_letter = 0
bad_list = ["ab","cd","pq","xy"]
input.split("\n").each do |x|
  current = x.split("")
  p x

  for i in 1..15
    if current[i-1] == current[i] then
      double_letter = 1
    end
    if bad_list.include? current[i-1] + current[i] then
      nice = 0
    end
    if vowel_list.include? current[i] then
      vowels +=1
    end
    if i == 1 then
      if vowel_list.include? current[0] then
        vowels += 1
      end
    end

  end
  if nice == 1 && vowels >= 3 && double_letter == 1 then
    nice_list +=1
  end
  p nice
  p vowels
  p double_letter
  p nice_list
  nice = 1
  vowels = 0
  double_letter = 0
end
p nice_list


text:
<?php

namespace Magento\Vault\Block;

use Magento\Vault\Api\Data\PaymentTokenInterface;

/**
 * Interface CardRendererInterface
 * @api
 */
interface CardRendererInterface extends TokenRendererInterface
{
    /**
     * @return string
     */
    public function getNumberLast4Digits();

    /**
     * @return string
     */
    public function getExpDate();

    /**
     * @return string
     */
    public function getIconUrl();

    /**
     * @return int
     */
    public function getIconHeight();

    /**
     * @return int
     */
    public function getIconWidth();

    /**
     * @return PaymentTokenInterface
     */
    public function getToken();
}


text:
package io.fabric8.cxf.endpoint;

import java.util.ArrayList;
import java.util.List;

import org.apache.cxf.Bus;
import org.apache.cxf.endpoint.Endpoint;
import org.apache.cxf.endpoint.EndpointImpl;
import org.apache.cxf.endpoint.Server;
import org.apache.cxf.feature.Feature;
import org.apache.cxf.interceptor.InterceptorProvider;
import org.apache.cxf.service.factory.AbstractServiceFactoryBean;
import org.apache.cxf.service.factory.FactoryBeanListener;
import org.apache.cxf.service.factory.FactoryBeanListenerManager;

public class SwaggerFeature extends org.apache.cxf.jaxrs.swagger.SwaggerFeature {

    @Override
    protected void initializeProvider(InterceptorProvider provider, final Bus bus) {
        if (!(provider instanceof Endpoint)) {
            FactoryBeanListenerManager factoryBeanListenerManager = bus.getExtension(FactoryBeanListenerManager.class);
            if (factoryBeanListenerManager == null) {
                factoryBeanListenerManager = new FactoryBeanListenerManager(bus);
            }
            factoryBeanListenerManager.addListener(new FactoryBeanListener() {
                @Override
                public void handleEvent(Event arg0, AbstractServiceFactoryBean arg1, Object... arg2) {
                    if (arg0.equals(Event.SERVER_CREATED) && (arg2[0] instanceof Server)) {
                        Server server = (Server)arg2[0];
                        if (server.getEndpoint().getEndpointInfo().getBinding().
                            getBindingId().equals("http://apache.org/cxf/binding/jaxrs")) {
                            initialize(server, bus);
                        }
                    }
                }
            });
            return;
        }
        EndpointImpl endpointImpl = (EndpointImpl)provider;
        List<Feature> features = endpointImpl.getActiveFeatures();
        if (features == null) {
            features = new ArrayList<Feature>();
            features.add(this);
            endpointImpl.initializeActiveFeatures(features);
        } else {
            features.add(this);
        }
    }

    @Override
    public String getBasePath() {
        // HACK: without this, swagger-ui will invoke endpoints using http://host:8181/crm without using /cxf servlet base path
        return super.getBasePath() == null ? null : "/cxf" + super.getBasePath();
    }
}


text:
import { ObjectID } from 'mongodb'
import randomString from 'crypto-random-string'

import { generateAPIKey } from './scripts/util'
import { Database } from './Database'

export const MAX_LENGTH_USERNAME = 20
export const MIN_LENGTH_USERNAME = 3

export abstract class Account {
  public static async createAccount ({ googleid, username, email, idtoken }: any): Promise<any> {
    if (username.length < MIN_LENGTH_USERNAME) throw new Error('Username received by Google account was too short')
    if (username.length > MAX_LENGTH_USERNAME) username = username.substr(0, MAX_LENGTH_USERNAME)
    const accountNames = (await Database.filterAccounts().toArray()).map((ac: any): string => ac.username)
    while (accountNames.includes(username)) {
      username = username.substr(0, 15) + randomString(3)
    }
    return (await Database.addAccount({
      googleid,
      username,
      email,
      idtoken,
      apikey: generateAPIKey()
    })).ops[0]
  }

  public static async getAccount ({ accountId, googleid, apikey, idtoken }: any, hideSensitive = true): Promise<any> {
    const filter: any = {}
    if (accountId) filter._id = accountId
    if (googleid) filter.googleid = googleid
    if (apikey) filter.apikey = apikey
    if (idtoken) filter.idtoken = idtoken
    if (Object.keys(filter).length === 0) return null
    let res = await Database.filterAccounts(filter).toArray()
    if (res.length === 0) return null
    const account = res[0]
    await Account.prepare(account)
    account.toJSON = Account.toJSON.bind(account, hideSensitive)
    return account
  }

  public static getAccountByAccountId (accountId: string, hideSensitive?: boolean): any {
    return Account.getAccount({ accountId: new ObjectID(accountId) }, hideSensitive)
  }

  public static getAccountByGoogleId (googleId: any, hideSensitive?: boolean): any {
    return Account.getAccount({ googleid: googleId }, hideSensitive)
  }

  public static getAccountByAPIKey (apiKey: string, hideSensitive?: boolean): any {
    return Account.getAccount({ apikey: apiKey }, hideSensitive)
  }

  public static getAccountBySession (idToken: any, hideSensitive?: boolean): Promise<any> {
    return Account.getAccount({ idtoken: idToken }, hideSensitive)
  }

  public static getAccountAmount (): any {
    return Database.getAccountsCount()
  }

  public static async prepare (account: any): Promise<any> {
    const stars = await Database.getAccountStars(account._id)
    const stars64 = await Database.getAccountStars64(account._id)
    account.stars = []
    account.stars64 = []
    for (let i in stars) {
      account.stars.push(stars[i].courseId)
    }
    for (let i in stars64) {
      account.stars64.push(stars64[i].courseId)
    }
    return account
  }

  public static async update (account: any, { username, downloadFormat }: any): Promise<any> {
    const update: any = {}
    if (username) {
      update.username = username
      account.username = username
    }
    if (downloadFormat != null) {
      update.downloadformat = downloadFormat
      account.downloadformat = downloadFormat
    }
    await Database.updateAccount(account._id, update)
  }

  public static async updateNet64Server (account: any, server: any): Promise<string> {
    const _server = await Database.getNet64Server(account._id)
    if (_server) {
      Database.updateNet64Server(_server._id, server)
      return _server._id
    } else {
      return (await Database.insertNet64Server(server)).insertedId
    }
  }

  public static login (accountId: any, idToken: any): any {
    return Database.updateAccount(accountId, { idtoken: idToken })
  }

  public static logout (accountId: any): any {
    return Database.updateAccount(accountId, { idtoken: undefined })
  }

  public static toJSON (hideSensitive = true): any {
    return Object.assign({
      username: (this as any).username,
      id: (this as any)._id,
      downloadformat: (this as any).downloadformat != null ? (this as any).downloadformat : 0,
      stars: (this as any).stars,
      stars64: (this as any).stars64
    }, hideSensitive ? {} : {
      apikey: (this as any).apikey
    }, (this as any).permissions ? {
      permissions: (this as any).permissions
    } : {})
  }
}


text:
using namespace Manta;
using namespace std;

void UDAReader::readUDA(string directory, string)
{
    cerr << "UDAReader compiled without libxml, please link libxml2 and recompile Manta\n";
}

void UDAReader::readUDAHeader(string directory)
{
    cerr << "UDAReader compiled without libxml, please link libxml2 and recompile Manta\n";
}


text:
describe('Clear operations', function () {
    var dbName;
    var conn;

    function openConnection(done) {
        dbName = 'dbName' + Math.random();

        openBaseConnection(dbName).then(function (connection) {
            conn = connection;
            done();
        }).catch(function () {
            done.fail('Open connection op failed');
        });
    }

    function closeConnection(done) {
        if (!conn) {
            done();
            return;
        }

        conn.close();
        conn = null;

        sklad.deleteDatabase(dbName).then(done).catch(function () {
            done();
        });
    }

    beforeEach(openConnection);

    it('should produce Error with NotFoundError name field when wrong object stores are used', function (done) {
        conn.clear('missing_object_store').then(function () {
            done.fail('Clear returns resolved promise');
        }).catch(function (err) {
            expect(err instanceof Error).toBe(true);
            expect(err.name).toEqual('NotFoundError');

            done();
        });
    });

    it('should clear one object store without errors', function (done) {
        conn.clear('keypath_true__keygen_false_0').then(done).catch(function (err) {
            done.fail('Clear returns rejected promise: ' + err.message + '\n' + err.stack);
        });
    });

    it('should clear multiple object stores without errors', function (done) {
        conn.clear(['keypath_true__keygen_false_0', 'keypath_true__keygen_false_1']).then(done).catch(function (err) {
            done.fail('Clear returns rejected promise: ' + err.message + '\n' + err.stack);
        });
    });

    afterEach(closeConnection);
});