text:
package com.linecorp.armeria.it.thrift;

import static com.linecorp.armeria.common.thrift.ThriftSerializationFormats.BINARY;
import static org.assertj.core.api.Assertions.assertThat;

import java.time.Duration;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import org.junit.ClassRule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import com.google.common.base.Stopwatch;

import com.linecorp.armeria.client.Client;
import com.linecorp.armeria.client.ClientBuilder;
import com.linecorp.armeria.client.ClientRequestContext;
import com.linecorp.armeria.client.SimpleDecoratingClient;
import com.linecorp.armeria.common.RequestContext;
import com.linecorp.armeria.common.RpcRequest;
import com.linecorp.armeria.common.RpcResponse;
import com.linecorp.armeria.server.ServerBuilder;
import com.linecorp.armeria.server.Service;
import com.linecorp.armeria.server.ServiceRequestContext;
import com.linecorp.armeria.server.SimpleDecoratingService;
import com.linecorp.armeria.server.thrift.THttpService;
import com.linecorp.armeria.server.thrift.ThriftCallService;
import com.linecorp.armeria.service.test.thrift.main.SleepService;
import com.linecorp.armeria.testing.server.ServerRule;

/**
 * Tests if Armeria decorators can alter the request/response timeout specified in Thrift call parameters
 * and disable the request/response timeout dynamically.
 */
@RunWith(Parameterized.class)
public class ThriftDynamicTimeoutTest {

    private static final SleepService.AsyncIface sleepService = (delay, resultHandler) ->
            RequestContext.current().eventLoop().schedule(
                    () -> resultHandler.onComplete(delay), delay, TimeUnit.MILLISECONDS);

    private static final SleepService.AsyncIface fakeSleepService = (delay, resultHandler) ->
            RequestContext.current().eventLoop().execute(
                    () -> resultHandler.onComplete(delay));

    /**
     * Runs the tests with:
     * - the client with dynamic timeout enabled and
     * - the client that disables timeout dynamically.
     */
    @Parameters
    public static Collection<Function<Client<RpcRequest, RpcResponse>,
                                      Client<RpcRequest, RpcResponse>>> parameters() {
        return Arrays.asList(DynamicTimeoutClient::new, TimeoutDisablingClient::new);
    }

    @ClassRule
    public static final ServerRule server = new ServerRule() {
        @Override
        protected void configure(ServerBuilder sb) throws Exception {
            // Used for testing if changing the timeout dynamically works.
            sb.service("/sleep", ThriftCallService.of(sleepService)
                                                  .decorate(DynamicTimeoutService::new)
                                                  .decorate(THttpService.newDecorator()));
            // Used for testing if disabling the timeout dynamically works.
            sb.service("/fakeSleep", ThriftCallService.of(fakeSleepService)
                                                      .decorate(TimeoutDisablingService::new)
                                                      .decorate(THttpService.newDecorator()));
            sb.defaultRequestTimeout(Duration.ofSeconds(1));
        }
    };

    private final Function<Client<RpcRequest, RpcResponse>,
            Client<RpcRequest, RpcResponse>> clientDecorator;

    public ThriftDynamicTimeoutTest(Function<Client<RpcRequest, RpcResponse>,
            Client<RpcRequest, RpcResponse>> clientDecorator) {
        this.clientDecorator = clientDecorator;
    }

    @Test
    public void testDynamicTimeout() throws Exception {
        final SleepService.Iface client = new ClientBuilder(server.uri(BINARY, "/sleep"))
                .decorator(RpcRequest.class, RpcResponse.class, clientDecorator)
                .defaultResponseTimeout(Duration.ofSeconds(1)).build(SleepService.Iface.class);

        final long delay = 1500;
        final Stopwatch sw = Stopwatch.createStarted();
        client.sleep(delay);
        assertThat(sw.elapsed(TimeUnit.MILLISECONDS)).isGreaterThanOrEqualTo(delay);
    }

    @Test(timeout = 10000)
    public void testDisabledTimeout() throws Exception {
        final SleepService.Iface client = new ClientBuilder(server.uri(BINARY, "/fakeSleep"))
                .decorator(RpcRequest.class, RpcResponse.class, clientDecorator)
                .defaultResponseTimeout(Duration.ofSeconds(1)).build(SleepService.Iface.class);

        // This call should take very short amount of time because the fakeSleep service does not sleep.
        client.sleep(30000);
    }

    private static final class DynamicTimeoutService extends SimpleDecoratingService<RpcRequest, RpcResponse> {

        DynamicTimeoutService(Service<RpcRequest, RpcResponse> delegate) {
            super(delegate);
        }

        @Override
        public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception {
            ctx.setRequestTimeoutMillis(((Number) req.params().get(0)).longValue() +
                                        ctx.requestTimeoutMillis());
            return delegate().serve(ctx, req);
        }
    }

    private static final class TimeoutDisablingService
            extends SimpleDecoratingService<RpcRequest, RpcResponse> {

        TimeoutDisablingService(Service<RpcRequest, RpcResponse> delegate) {
            super(delegate);
        }

        @Override
        public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception {
            ctx.setRequestTimeoutMillis(0);
            return delegate().serve(ctx, req);
        }
    }

    private static final class DynamicTimeoutClient
            extends SimpleDecoratingClient<RpcRequest, RpcResponse> {

        DynamicTimeoutClient(Client<RpcRequest, RpcResponse> delegate) {
            super(delegate);
        }

        @Override
        public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception {
            ctx.setResponseTimeoutMillis(((Number) req.params().get(0)).longValue() +
                                         ctx.responseTimeoutMillis());
            return delegate().execute(ctx, req);
        }
    }

    private static final class TimeoutDisablingClient
            extends SimpleDecoratingClient<RpcRequest, RpcResponse> {

        TimeoutDisablingClient(Client<RpcRequest, RpcResponse> delegate) {
            super(delegate);
        }

        @Override
        public RpcResponse execute(ClientRequestContext ctx, RpcRequest req) throws Exception {
            ctx.setResponseTimeoutMillis(0);
            return delegate().execute(ctx, req);
        }
    }
}


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

  Pathname: idct16.h

------------------------------------------------------------------------------
 REVISION HISTORY

 Who:                                       Date:
 Description:
------------------------------------------------------------------------------
 INCLUDE DESCRIPTION

------------------------------------------------------------------------------
*/

#ifndef IDCT16_H
#define IDCT16_H

/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/

#include "pv_audio_type_defs.h"

/*----------------------------------------------------------------------------
; MACROS
; Define module specific macros here
----------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C"
{
#endif

    /*----------------------------------------------------------------------------
    ; EXTERNAL VARIABLES REFERENCES
    ----------------------------------------------------------------------------*/

    /*----------------------------------------------------------------------------
    ; DEFINES AND SIMPLE TYPEDEF'S
    ----------------------------------------------------------------------------*/

    void idct_16(Int32 vec[], Int32 scratch_mem[]);

#ifdef __cplusplus
}
#endif

#endif  /* IDCT16_H */

redpajama_set_name: RedPajamaGithub


text:
using System;

using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.X509;

namespace Org.BouncyCastle.Asn1.Cms
{
    /**
     * RFC 3274 - CMS Compressed Data.
     * <pre>
     * CompressedData ::= Sequence {
     *  version CMSVersion,
     *  compressionAlgorithm CompressionAlgorithmIdentifier,
     *  encapContentInfo EncapsulatedContentInfo
     * }
     * </pre>
     */
    public class CompressedData
        : Asn1Encodable
    {
        private DerInteger			version;
        private AlgorithmIdentifier	compressionAlgorithm;
        private ContentInfo			encapContentInfo;

		public CompressedData(
            AlgorithmIdentifier	compressionAlgorithm,
            ContentInfo			encapContentInfo)
        {
            this.version = new DerInteger(0);
            this.compressionAlgorithm = compressionAlgorithm;
            this.encapContentInfo = encapContentInfo;
        }

		public CompressedData(
            Asn1Sequence seq)
        {
            this.version = (DerInteger) seq[0];
            this.compressionAlgorithm = AlgorithmIdentifier.GetInstance(seq[1]);
            this.encapContentInfo = ContentInfo.GetInstance(seq[2]);
        }

		/**
         * return a CompressedData object from a tagged object.
         *
         * @param ato the tagged object holding the object we want.
         * @param explicitly true if the object is meant to be explicitly
         *              tagged false otherwise.
         * @exception ArgumentException if the object held by the
         *          tagged object cannot be converted.
         */
        public static CompressedData GetInstance(
            Asn1TaggedObject ato,
            bool explicitly)
        {
            return GetInstance(Asn1Sequence.GetInstance(ato, explicitly));
        }

        /**
         * return a CompressedData object from the given object.
         *
         * @param _obj the object we want converted.
         * @exception ArgumentException if the object cannot be converted.
         */
        public static CompressedData GetInstance(
            object obj)
        {
            if (obj == null || obj is CompressedData)
            {
                return (CompressedData)obj;
            }

            if (obj is Asn1Sequence)
            {
                return new CompressedData((Asn1Sequence) obj);
            }

			throw new ArgumentException("Invalid CompressedData: " + obj.GetType().Name);
        }

		public DerInteger Version
		{
			get { return version; }
		}

		public AlgorithmIdentifier CompressionAlgorithmIdentifier
		{
			get { return compressionAlgorithm; }
		}

		public ContentInfo EncapContentInfo
		{
			get { return encapContentInfo; }
		}

		public override Asn1Object ToAsn1Object()
        {
			return new BerSequence(version, compressionAlgorithm, encapContentInfo);
        }
    }
}


text:
import 'isomorphic-fetch';
import FetchClient from '../../src/index.js';

describe('Middleware features', () => {

  let url    = 'http://example.com/page';
  let client = new FetchClient();
  let stub;

  let middleware1 = {
    request(req) {
      req.headers.set('x-req-fake1', true);
      return req;
    },

    requestError(error) {
      return global.Promise.reject(error);
    },

    response(res) {
      res.headers.set('x-res-fake1', true);
      return res;
    },

    responseError(error) {
      return global.Promise.reject(error);
    }
  };

  let middleware2 = {
    request(req) {
      req.headers.set('x-req-fake2', true);
      return req;
    },

    requestError(error) {
      return global.Promise.reject(error);
    },

    response(res) {
      res.headers.set('x-res-fake2', true);
      return res;
    },

    responseError(error) {
      return global.Promise.reject(error);
    }
  };

  before(() => stub = sinon.stub(global, 'fetch', () => {
    return new global.Response('response');
  }));

  after(() => global.fetch.restore());

  beforeEach(() => stub.reset());

  afterEach(() => client.clearMiddlewares());

  it('should call request() before calling global.fetch', (done) => {

    let middleware1RequestStub = sinon.spy(middleware1, 'request');

    client.addMiddlewares([middleware1]);
    client.fetch(url)
      .then(() => {

        expect(middleware1RequestStub.callCount).to.be.equal(1);
        expect(stub.callCount).to.be.equal(1);
        expect(stub.getCall(0).args[0].headers.has('x-req-fake1'))
          .to.be.equal(true);

        middleware1RequestStub.restore();

        done();
      })
      .catch(done.fail);
  });

  it('should call response() after calling global.fetch', (done) => {

    let middleware1ResponseStub = sinon.spy(middleware1, 'response');

    client.addMiddlewares([middleware1]);
    client.fetch(url)
      .then((res) => {

        expect(middleware1ResponseStub.callCount).to.be.equal(1);
        expect(stub.callCount).to.be.equal(1);
        expect(stub.getCall(0).args[0].headers.has('x-req-fake1'))
          .to.be.equal(true);
        expect(stub.getCall(0).args[0].headers.has('x-res-fake1'))
          .to.be.equal(false);
        expect(res.headers.has('x-res-fake1')).to.be.equal(true);

        middleware1ResponseStub.restore();

        done();
      })
      .catch(done.fail);
  });

  it(`should call requestError() when current middleware request() threw an error`, (done) => {

    let middleware1RequestStub      = sinon.stub(middleware1, 'request').throws();
    let middleware1RequestErrorStub = sinon.spy(middleware1, 'requestError');
    let middleware2RequestStub      = sinon.stub(middleware2, 'request');
    let middleware2RequestErrorStub = sinon.spy(middleware2, 'requestError');

    let middleware1ResponseStub      = sinon.stub(middleware1, 'response');
    let middleware1ResponseErrorStub = sinon.spy(middleware1, 'responseError');
    let middleware2ResponseStub      = sinon.stub(middleware2, 'response');
    let middleware2ResponseErrorStub = sinon.spy(middleware2, 'responseError');

    client.addMiddlewares(middleware1);
    client.addMiddlewares(middleware2);
    client.addMiddlewares(null);
    client.addMiddlewares({});

    client.fetch(url)
      .then(done.fail)
      .catch(() => {

        expect(middleware1RequestStub.callCount).to.be.equal(1);
        expect(middleware2RequestStub.callCount).to.be.equal(0);
        expect(middleware1RequestErrorStub.callCount).to.be.equal(1);
        expect(middleware2RequestErrorStub.callCount).to.be.equal(1);

        expect(stub.callCount).to.be.equal(0);

        expect(middleware1ResponseStub.callCount).to.be.equal(0);
        expect(middleware2ResponseStub.callCount).to.be.equal(0);
        expect(middleware1ResponseErrorStub.callCount).to.be.equal(1);
        expect(middleware2ResponseErrorStub.callCount).to.be.equal(1);

        middleware1RequestStub.restore();
        middleware1RequestErrorStub.restore();
        middleware2RequestStub.restore();
        middleware2RequestErrorStub.restore();

        middleware1ResponseStub.restore();
        middleware1ResponseErrorStub.restore();
        middleware2ResponseStub.restore();
        middleware2ResponseErrorStub.restore();

        done();
      });
  });

  it(`should call responseError() when current middleware response() threw an error`, (done) => {

    let middleware1RequestStub      = sinon.stub(middleware1, 'request');
    let middleware1RequestErrorStub = sinon.stub(middleware1, 'requestError');
    let middleware2RequestStub      = sinon.stub(middleware2, 'request');
    let middleware2RequestErrorStub = sinon.stub(middleware2, 'requestError');

    let middleware1ResponseStub      = sinon.stub(middleware1, 'response').throws();
    let middleware1ResponseErrorStub = sinon.spy(middleware1, 'responseError');
    let middleware2ResponseStub      = sinon.stub(middleware2, 'response');
    let middleware2ResponseErrorStub = sinon.spy(middleware2, 'responseError');

    client.addMiddlewares([middleware1, middleware2]);
    client.fetch(url)
      .then(done.fail)
      .catch(() => {

        expect(middleware1RequestStub.callCount).to.be.equal(1);
        expect(middleware2RequestStub.callCount).to.be.equal(1);
        expect(middleware1RequestErrorStub.callCount).to.be.equal(0);
        expect(middleware2RequestErrorStub.callCount).to.be.equal(0);

        expect(stub.callCount).to.be.equal(1);

        expect(middleware1ResponseStub.callCount).to.be.equal(1);
        expect(middleware2ResponseStub.callCount).to.be.equal(0);
        expect(middleware1ResponseErrorStub.callCount).to.be.equal(1);
        expect(middleware2ResponseErrorStub.callCount).to.be.equal(1);

        middleware1RequestStub.restore();
        middleware1RequestErrorStub.restore();
        middleware2RequestStub.restore();
        middleware2RequestErrorStub.restore();

        middleware1ResponseStub.restore();
        middleware1ResponseErrorStub.restore();
        middleware2ResponseStub.restore();
        middleware2ResponseErrorStub.restore();

        done();
      });
  });

  it('should calls middlewares in order', (done) => {

    let middleware1RequestStub      = sinon.spy(middleware1, 'request');
    let middleware2RequestStub      = sinon.spy(middleware2, 'request');
    let middleware1RequestErrorStub = sinon.stub(middleware1, 'requestError');
    let middleware2RequestErrorStub = sinon.stub(middleware2, 'requestError');

    let middleware1ResponseStub      = sinon.spy(middleware1, 'response');
    let middleware2ResponseStub      = sinon.spy(middleware2, 'response');
    let middleware1ResponseErrorStub = sinon.stub(middleware1, 'responseError');
    let middleware2ResponseErrorStub = sinon.stub(middleware2, 'responseError');

    client.addMiddlewares([middleware1, middleware2]);
    client.fetch(url)
      .then((res) => {

        expect(middleware1RequestStub.callCount).to.be.equal(1);
        expect(middleware2RequestStub.callCount).to.be.equal(1);
        expect(middleware1RequestErrorStub.callCount).to.be.equal(0);
        expect(middleware2RequestErrorStub.callCount).to.be.equal(0);
        expect(stub.callCount).to.be.equal(1);
        expect(middleware1ResponseStub.callCount).to.be.equal(1);
        expect(middleware2ResponseStub.callCount).to.be.equal(1);
        expect(middleware1ResponseErrorStub.callCount).to.be.equal(0);
        expect(middleware2ResponseErrorStub.callCount).to.be.equal(0);

        expect(middleware2RequestStub.getCall(0).args[0].headers.has('x-req-fake1')).to.be.equal(true);
        expect(stub.getCall(0).args[0].headers.has('x-req-fake1')).to.be.equal(true);
        expect(stub.getCall(0).args[0].headers.has('x-req-fake2')).to.be.equal(true);
        expect(middleware1ResponseStub.getCall(0).args[0].headers['x-res-fake1']).to.be.undefined;
        expect(middleware1ResponseStub.getCall(0).args[0].headers['x-res-fake2']).to.be.undefined;
        expect(middleware2ResponseStub.getCall(0).args[0].headers.has('x-res-fake1')).to.be.equal(true);
        expect(middleware2ResponseStub.getCall(0).args[0].headers['x-res-fake2']).to.be.undefined;
        expect(res.headers.has('x-res-fake1')).to.be.equal(true);
        expect(res.headers.has('x-res-fake2')).to.be.equal(true);

        middleware1RequestStub.restore();
        middleware2RequestStub.restore();
        middleware1RequestErrorStub.restore();
        middleware2RequestErrorStub.restore();

        middleware1ResponseStub.restore();
        middleware2ResponseStub.restore();
        middleware1ResponseErrorStub.restore();
        middleware2ResponseErrorStub.restore();

        done();
      })
      .catch(done.fail);
  });
});


text:
using System;
using System.Collections.Generic;

namespace StickEmApp.Entities
{
    public class StickerSalesPeriod
    {
        public virtual Guid Id { get; set; }
        public virtual int NumberOfStickersToSell { get; set; }

        public virtual SalesPeriodStatus CalculateStatus(IReadOnlyCollection<Vendor> vendors)
        {
            var status = new SalesPeriodStatus
            {
                NumberOfStickersToSell = NumberOfStickersToSell,
                NumberOfStickersSold = 0,
                NumberOfStickersRemaining = NumberOfStickersToSell
            };

            foreach (var vendor in vendors)
            {
                var vendorResult = vendor.CalculateSalesResult();

                if (vendor.Status == VendorStatus.Finished)
                {
                    status.NumberOfStickersSold += vendorResult.NumberOfStickersSold;
                    status.NumberOfStickersRemaining -= vendorResult.NumberOfStickersSold;
                }
                else
                {
                    status.NumberOfStickersWithVendors += vendorResult.NumberOfStickersReceived;
                    status.NumberOfStickersRemaining -= vendorResult.NumberOfStickersReceived;
                }
            }

            status.SalesTotal = status.NumberOfStickersSold * Sticker.Price;

            return status;
        }
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:fab="http://schemas.android.com/apk/res-auto"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent">

        <FrameLayout
                android:id="@+id/fragmentContainer"
                android:layout_width="match_parent"
                android:layout_height="match_parent" />

        <com.melnykov.fab.FloatingActionButton
                android:id="@+id/fab"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentBottom="true"
                android:layout_alignParentRight="true"
                android:layout_gravity="bottom|right"
                android:layout_margin="16dp"
                fab:fab_colorNormal="@color/accent"
                fab:fab_colorPressed="@color/primary_dark" />

</LinearLayout>


text:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
                xmlns:tools="http://schemas.android.com/tools"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:padding="2dp"
                tools:context=".ArticlesActivity$PlaceholderFragment">

    <ProgressBar
        android:id="@+id/processing"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:indeterminateBehavior="cycle"
        android:indeterminate="true"
        android:visibility="gone"
        android:max="100"
        />

    <ListView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/articles"/>

</RelativeLayout>


text:
import controller from "./angular-button-group-controller";
import template from "./angular-button-group-template.html!text";

export default {
    bindings: {
        is_visible: "=?isVisible",
        config:     "=?",
        api:        "=?"
    },
    controller: controller,
    controllerAs: "AngularButtonGroup",
    template: template
};


text:
import os, sys, tarfile, urllib
import numpy as np
import matplotlib.pyplot as plt

# image shape
HEIGHT = 96
WIDTH = 96
DEPTH = 3

# size of a single image in bytes
SIZE = HEIGHT * WIDTH * DEPTH

# path to the directory with the data
DATA_DIR = './data'

# url of the binary data
DATA_URL = 'http://ai.stanford.edu/~acoates/stl10/stl10_binary.tar.gz'

# path to the binary train file with image data
DATA_PATH = './data/stl10_binary/train_X.bin'

# path to the binary train file with labels
LABEL_PATH = './data/stl10_binary/train_y.bin'

def read_labels(path_to_labels):
    """
    :param path_to_labels: path to the binary file containing labels from the STL-10 dataset
    :return: an array containing the labels
    """
    with open(path_to_labels, 'rb') as f:
        labels = np.fromfile(f, dtype=np.uint8)
        return labels

def read_all_images(path_to_data):
    """
    :param path_to_data: the file containing the binary images from the STL-10 dataset
    :return: an array containing all the images
    """

    with open(path_to_data, 'rb') as f:
        # read whole file in uint8 chunks
        everything = np.fromfile(f, dtype=np.uint8)

        # We force the data into 3x96x96 chunks, since the
        # images are stored in "column-major order", meaning
        # that "the first 96*96 values are the red channel,
        # the next 96*96 are green, and the last are blue."
        # The -1 is since the size of the pictures depends
        # on the input file, and this way numpy determines
        # the size on its own.

        images = np.reshape(everything, (-1, 3, 96, 96))

        # Now transpose the images into a standard image format
        # readable by, for example, matplotlib.imshow
        # You might want to comment this line or reverse the shuffle
        # if you will use a learning algorithm like CNN, since they like
        # their channels separated.
        images = np.transpose(images, (0, 3, 2, 1))
        return images

def read_single_image(image_file):
    """
    CAREFUL! - this method uses a file as input instead of the path - so the
    position of the reader will be remembered outside of context of this method.
    :param image_file: the open file containing the images
    :return: a single image
    """
    # read a single image, count determines the number of uint8's to read
    image = np.fromfile(image_file, dtype=np.uint8, count=SIZE)
    # force into image matrix
    image = np.reshape(image, (3, 96, 96))
    # transpose to standard format
    # You might want to comment this line or reverse the shuffle
    # if you will use a learning algorithm like CNN, since they like
    # their channels separated.
    image = np.transpose(image, (2, 1, 0))
    return image

def plot_image(image):
    """
    :param image: the image to be plotted in a 3-D matrix format
    :return: None
    """
    plt.imshow(image)
    plt.show()

def download_and_extract():
    """
    Download and extract the STL-10 dataset
    :return: None
    """
    dest_directory = DATA_DIR
    if not os.path.exists(dest_directory):
        os.makedirs(dest_directory)
    filename = DATA_URL.split('/')[-1]
    filepath = os.path.join(dest_directory, filename)
    if not os.path.exists(filepath):
        def _progress(count, block_size, total_size):
            sys.stdout.write('\rDownloading %s %.2f%%' % (filename,
                float(count * block_size) / float(total_size) * 100.0))
            sys.stdout.flush()
        filepath, _ = urllib.urlretrieve(DATA_URL, filepath, reporthook=_progress)
        print('Downloaded', filename)
        tarfile.open(filepath, 'r:gz').extractall(dest_directory)

if __name__ == "__main__":
    # download data if needed
    download_and_extract()

    # test to check if the image is read correctly
    with open(DATA_PATH) as f:
        image = read_single_image(f)
        plot_image(image)

    # test to check if the whole dataset is read correctly
    images = read_all_images(DATA_PATH)
    print images.shape

    labels = read_labels(LABEL_PATH)
    print labels.shape


text:
<project name="library_configuration">
  <property name="configuration.library.version" value="1.0.0" description="The current version of the library" />
  <dirname property="library_configuration.basedir" file="${ant.file.library_configuration}"/>

  <property name="configuration.library.resfile.pomConfiguration.merge" location="${main.root}/maven/pomConfiguration_xmlMerge.properties" description="A mandatory resource-file of the library, defines how to merge pom-files" />
  <property name="configuration.library.resfile.js.general" location="${main.root}/javascripts/library_configuration/general.js" description="JavaScript which holds the general implementations and includes all other libraries" />

  <property name="configuration.version.property" value="" description="The name of the property to read to determine the version to be build." />
  <property name="configuration.properties.location" value="" description="The absolute location to load the customer's settings from, should be defined in the scriptconfig.properties" />
  <property name="configuration.versions.foldername" value="" description="The name of the folder in which the versions are found, must be a relative path to the base-directory, i.e. the folder in which the build.xml is found" />
  <property name="configuration.settings.defaultconfig" value="_default" description="The folder in which the default configuration can be found" />
  <property name="configuration.settings.defaultcustomer" value="default" description="The folder in which the default customer can be found" />
  <property name="configuration.config.filename" value="config.properties" description="The name of the property-file to be read for a customer's configuration" />
  <property name="configuration.config.import.filename" value="import.properties" description="The name of the configuration file to be read for imports" />
  <property name="configuration.config.user.filename" value="alternative.properties" description="The name of the configuration file to be read for the user (overrides the other settings), this file is only read if the 'alternative' configuration is loaded" />
  <property name="configuration.resources.foldername" value="resources" description="The folder in which resources added for the customer are located" />
  <property name="configuration.location" value="${user.name}" description="The property defines the path (relative to the project's root or absolute) to the location at which the application (defined by the selected configuration) should be build" />

  <property name="configuration.resource.dependency" value="configuration.dependency" description="The resource type of a dependency" />
  <property name="configuration.replacement.default.pattern" value="${file.replacement.default.pattern}" description="The pattern to check which files should be property-replaced" />
  <property name="configuration.replacement.additional.pattern" value="" description="Additional list of pattern, i.e. \.script|\.test to check for files of property replacement" />

  <property name="configuration.resourcetype.dependency" value="configuration.dependency" description="The resource-type used by the configurationMapper to identify dependencies" />
  <property name="configuration.resourcetype.resource" value="configuration.resource" description="The resource-type used by the configurationMapper to identify resources" />

  <property name="configuration.init" value="false" description="For internal usage only, please do not modify this property by a file" />

  <taskdef resource="net/sf/antcontrib/antlib.xml" />

  <if>
    <equals arg1="${configuration.init}" arg2="false" />
    <then>

      <if>
        <not><isset property="customer" /></not>
        <then>
          <property name="customer" value="${configuration.settings.defaultcustomer}" />
        </then>
      </if>

      <if>
        <not><isset property="alternative" /></not>
        <then>
          <var name="alternative" value="false" />
        </then>
      </if>

      <property name="configuration.main.root" value="${basedir}" />
      <property name="configuration.settings.root" location="${configuration.properties.location}" />
      <property name="configuration.settings.pomfolder" location="${configuration.main.root}/${configuration.versions.foldername}" />
      <property name="configuration.settings.default" location="${configuration.settings.root}/${configuration.settings.defaultconfig}" />

      <var name="configuration.init" value="true" />
    </then>
  </if>

  <macrodef name="configurationLoadProperties">
    <attribute name="customer" default="${customer}" />
    <attribute name="alternative" default="${alternative}" />

    <sequential>
      <var name="configuration.customer" value="@{customer}" />

      <var file="${configuration.settings.default}/${configuration.config.filename}" />

      <if>
        <or>
          <equals arg1="@{alternative}" arg2="y" />
          <equals arg1="@{alternative}" arg2="yes" />
          <equals arg1="@{alternative}" arg2="true" />
        </or>
        <then>
          <var name="configuration.alternative" value="true" />
        </then>
        <else>
          <var name="configuration.alternative" value="false" />
        </else>
      </if>

      <for list="${configuration.settings.includedCustomers}" param="configuration.tmp.includedCustomer" delimiter="|" trim="true">
        <sequential>
          <var name="configuration.tmp.customerFolder" value="${configuration.settings.root}/@{configuration.tmp.includedCustomer}" />

          <if>
            <available file="${configuration.tmp.customerFolder}/${configuration.config.filename}" />
            <then>
              <var file="${configuration.tmp.customerFolder}/${configuration.config.filename}" />
            </then>
          </if>

          <if>
            <and>
              <equals arg1="${configuration.alternative}" arg2="true" />
              <available file="${configuration.tmp.customerFolder}/${configuration.config.user.filename}" />
            </and>
            <then>
              <var file="${configuration.tmp.customerFolder}/${configuration.config.user.filename}" />
            </then>
          </if>
        </sequential>
      </for>

      <propertyset id="configuration.tmp.propertiesSet">
        <propertyref regex=".*"/>
      </propertyset>
      <replacePropertiesInProperties propertySetId="configuration.tmp.propertiesSet" />
      <replacePropertiesInProperties propertySetId="main.tmp.propertiesSet" propertyMarker="@" />

      <configurationPostProperties />

    </sequential>
  </macrodef>

  <macrodef name="configurationLoadVersionProperties">
    <attribute name="version" default="${version}" />
    <attribute name="customer" default="${customer}" />

    <sequential>

      <for list="${configuration.settings.includedCustomers}" param="configuration.tmp.includedCustomer" delimiter="|" trim="true">
        <sequential>
          <var name="configuration.tmp.customerFolder" value="${configuration.settings.root}/@{configuration.tmp.includedCustomer}" />
          <if>
            <available file="${configuration.tmp.customerFolder}/${configuration.version.property}/files.xml" />
            <then>
              <var name="configuration.tmp.files.location" value="${java.io.tmpdir}/files.xml" />
              <fileReplaceAllProperties file="${configuration.tmp.customerFolder}/${configuration.version.property}/files.xml" destFile="${configuration.tmp.files.location}" />
              <xmlproperty file="${configuration.tmp.files.location}" prefix="@{configuration.tmp.includedCustomer}" />

              <fileCleanUp file="${configuration.tmp.files.location}" />
            </then>
          </if>
        </sequential>
      </for>

      <if>
        <and>
          <not><matches pattern="\$\{.+\}" string="@{version}" /></not>
          <not><matches pattern="@\{.+\}" string="@{version}" /></not>
        </and>
        <then>
          <var name="configuration.version" value="@{version}" />
        </then>
        <elseif>
          <or>
            <not><isset property="configuration.version.property" /></not>
            <equals arg1="${configuration.version.property}" arg2="" />
          </or>
          <then>
            <fail>The mandatory property 'version' cannot be determined.</fail>
          </then>
        </elseif>
        <else>
          <var name="configuration.version" value="" unset="true" />
          <propertycopy name="configuration.version" from="${configuration.version.property}" />
        </else>
      </if>

      <var name="configuration.settings.pom" value="${configuration.settings.pomfolder}/pom-${configuration.version}.xml" />
      <var name="configuration.settings.finalpom" value="${maven.tmpdir}/configuration_pom.xml" />
      <var name="configuration.settings.tmp.pom" value="${maven.tmpdir}/configuration_tmp_pom.xml" />

      <if>
        <available file="${configuration.settings.pom}" />
        <then>
          <copy file="${configuration.settings.pom}" tofile="${configuration.settings.finalpom}" overwrite="true" />

          <for list="${configuration.settings.includedCustomers}" param="configuration.tmp.includedCustomer" delimiter="|" trim="true">
            <sequential>
              <var name="configuration.tmp.customerFolder" value="${configuration.settings.root}/@{configuration.tmp.includedCustomer}" />
              <var name="configuration.settings.additionalpom" value="${configuration.tmp.customerFolder}/${configuration.version.property}/pom.xml" />

              <if>
                <available file="${configuration.settings.additionalpom}" />
                <then>
                  <copy file="${configuration.settings.finalpom}" tofile="${configuration.settings.tmp.pom}" overwrite="true" />
                  <fileMergeXml file1="${configuration.settings.tmp.pom}"
                                file2="${configuration.settings.additionalpom}"
                                dest="${configuration.settings.finalpom}"
                                conf="${configuration.library.resfile.pomConfiguration.merge}" />
                </then>
              </if>
            </sequential>
          </for>
        </then>
      </if>

      <if>
        <and>
          <available file="${configuration.settings.pom}" />
          <available file="${configuration.settings.finalpom}" />
        </and>
        <then>
          <mavenResolveDependencies fileset="configuration.dependencies.componentlibs" pomid="configuration.dependencies.componentpom" pomfile="${configuration.settings.pom}" />
          <mavenResolveDependencies fileset="configuration.dependencies.libs" pomid="configuration.dependencies.pom" pomfile="${configuration.settings.finalpom}" />
        </then>
      </if>

      <configurationPostVersionProperties />
    </sequential>
  </macrodef>

  <macrodef name="configurationSetup">
    <attribute name="location" />
    <attribute name="version" default="${version}" />
    <attribute name="customer" default="${customer}" />
    <attribute name="alternative" default="${alternative}" />

    <sequential>

      <var name="configuration.tmp.replacement.pattern" value="${configuration.replacement.default.pattern}" />
      <if>
        <and>
          <isset property="configuration.replacement.additional.pattern" />
          <not><equals arg1="${configuration.replacement.additional.pattern}" arg2="" /></not>
        </and>
        <then>
          <var name="configuration.tmp.replacement.pattern" value="${configuration.replacement.default.pattern}|${configuration.replacement.additional.pattern}" />
        </then>
      </if>

      <configurationLoadProperties customer="@{customer}" alternative="@{alternative}" />

      <configurationLoadVersionProperties customer="${configuration.customer}" version="@{version}" />

      <var name="configuration.tmp.location" value="@{location}/tmp" />
      <if>
        <resourcecount refid="configuration.dependencies.libs" when="equal" count="0" />
        <then>
          <fail>The '${configuration.settings.pom}' does not define a valid dependency please validate</fail>
        </then>
        <else>

          <fileCleanUp dir="${configuration.tmp.location}" recreate="true" />
          <fileCallMacroForEach macro="configurationBuildPackage" parameters="resourceType=[[${configuration.resourcetype.dependency}]];rootFolder=[[${configuration.tmp.location}]];filePattern=[[${configuration.tmp.replacement.pattern}]];">
            <fileset refid="configuration.dependencies.libs" />
          </fileCallMacroForEach>
        </else>
      </if>

      <configurationPostDependencies />

      <configurationPostFiles />

      <for list="${configuration.settings.includedCustomers}" param="configuration.tmp.includedCustomer" delimiter="|" trim="true">
        <sequential>
          <var name="configuration.tmp.customerFolder" value="${configuration.settings.root}/@{configuration.tmp.includedCustomer}" />
          <var name="configuration.resources.tmp.location" value="${configuration.tmp.customerFolder}/${configuration.version.property}/${configuration.resources.foldername}" />
          <if>
            <available file="${configuration.resources.tmp.location}" />
            <then>
              <fileCallMacroForEach macro="configurationBuildPackage" parameters="resourceType=[[${configuration.resourcetype.resource}]];rootFolder=[[${configuration.tmp.location}]];filePattern=[[${configuration.tmp.replacement.pattern}]];">
                <fileset dir="${configuration.resources.tmp.location}" />
              </fileCallMacroForEach>
            </then>
          </if>
        </sequential>
      </for>

      <configurationPostResources />

      <if>
        <or>
          <equals arg1="@{alternative}" arg2="y" />
          <equals arg1="@{alternative}" arg2="yes" />
          <equals arg1="@{alternative}" arg2="true" />
        </or>
        <then>
          <var name="configuration.tmp.zipFileName" value="${configuration.dependencies.pom.artifactId}-${configuration.version}-${configuration.customer}-alternative.zip" />
        </then>
        <else>
          <var name="configuration.tmp.zipFileName" value="${configuration.dependencies.pom.artifactId}-${configuration.version}-${configuration.customer}.zip" />
        </else>
      </if>

      <var name="configuration.zippedFile" value="@{location}/${configuration.tmp.zipFileName}" />
      <fileCleanUp file="${configuration.zippedFile}" />
      <zip destfile="${configuration.zippedFile}" basedir="${configuration.tmp.location}" />

      <fileCleanUp dir="${configuration.tmp.location}" recreate="false" />
    </sequential>
  </macrodef>

  <macrodef name="configurationPostProperties">
    <sequential />
  </macrodef>

  <macrodef name="configurationPostVersionProperties">
    <sequential />
  </macrodef>

  <macrodef name="configurationPostDependencies">
    <sequential />
  </macrodef>

  <macrodef name="configurationPostFiles">
    <sequential />
  </macrodef>

  <macrodef name="configurationPostResources">
    <sequential />
  </macrodef>

  <macrodef name="configurationCopyFiles">
    <attribute name="from" />
    <attribute name="to" />
    <attribute name="unzip" default="false" />
    <attribute name="includes" default="**/*" />
    <attribute name="excludes" default="" />
    <attribute name="ignore" default="false" />

    <sequential>
      <if>
        <or><equals arg1="@{ignore}" arg2="y" /><equals arg1="@{ignore}" arg2="yes" /><equals arg1="@{ignore}" arg2="true" /></or>
        <then>

        </then>
        <else>
          <fileInfo file="@{from}" />

          <if>
            <equals arg1="${fileInfo.dir}" arg2="true" />
            <then>
              <copy todir="@{to}">
                <fileset dir="@{from}" includes="@{includes}" excludes="@{excludes}" />
              </copy>
            </then>
            <else>
              <if>
                <or><equals arg1="@{unzip}" arg2="y" /><equals arg1="@{unzip}" arg2="yes" /><equals arg1="@{unzip}" arg2="true" /></or>
                <then>
                  <unzip src="@{from}" dest="@{to}" overwrite="true" />
                </then>
                <else>
                  <copy file="@{from}" todir="@{to}" />
                </else>
              </if>
            </else>
          </if>
        </else>
      </if>
    </sequential>
  </macrodef>

  <macrodef name="configurationBuildPackage">
    <attribute name="resourceFolder" />
    <attribute name="resourceFileName" />
    <attribute name="resource" />
    <attribute name="resourceType" />
    <attribute name="rootFolder" />
    <attribute name="filePattern" />
    <attribute name="basedir" />

    <sequential>
      <var name="confMapper.unzip" value="" />
      <var name="confMapper.location" value="" />
      <var name="confMapper.replaceProperties" value="true" />
      <var name="confMapper.useDefault" value="true" />
      <var name="confMapper.renameTo" value="" />

      <configurationCustomerMapper resourceType="@{resourceType}" resourceFolder="@{resourceFolder}" resource="@{resource}" resourceFileName="@{resourceFileName}" />
      <if>
        <or>
          <equals arg1="${confMapper.useDefault}" arg2="y" />
          <equals arg1="${confMapper.useDefault}" arg2="yes" />
          <equals arg1="${confMapper.useDefault}" arg2="true" />
        </or>
        <then>
          <configurationMapper resourceType="@{resourceType}" resourceFolder="@{resourceFolder}" resource="@{resource}" resourceFileName="@{resourceFileName}" />
        </then>
      </if>

      <if>
        <equals arg1="${confMapper.location}" arg2="" />
        <then>
          <var name="confMapper.location" value="   " />
        </then>
      </if>

      <if>
        <equals arg1="${confMapper.renameTo}" arg2="" />
        <then><var name="configuration.tmp.filename" value="@{resourceFileName}" /></then>
        <else><var name="configuration.tmp.filename" value="${confMapper.renameTo}" /></else>
      </if>

      <for list="${confMapper.location}" param="configuration.tmp.location" delimiter=":" trim="true">
        <sequential>
          <if>
            <and>
              <equals arg1="@{resourceType}" arg2="${configuration.resourcetype.dependency}" />
              <or>
                <equals arg1="${confMapper.unzip}" arg2="true" />
                <equals arg1="${confMapper.unzip}" arg2="y" />
                <equals arg1="${confMapper.unzip}" arg2="yes" />
                <and>
                  <matches pattern=".+\.zip$" string="@{resourceFileName}" />
                  <equals arg1="${confMapper.unzip}" arg2="" />
                </and>
              </or>
            </and>
            <then>
              <if>
                <equals arg1="${confMapper.replaceProperties}" arg2="true" />
                <then>
                  <fileReplaceAllPropertiesInZip file="@{resource}" dest="@{rootFolder}/@{configuration.tmp.location}" filePattern="@{filePattern}" rezip="false" />
                </then>
                <else>
                  <unzip src="@{resource}" dest="@{rootFolder}/@{configuration.tmp.location}" overwrite="true" />
                </else>
              </if>
            </then>
            <elseif>
              <equals arg1="@{resourceType}" arg2="${configuration.resourcetype.dependency}" />
              <then>
                <if>
                  <equals arg1="${confMapper.replaceProperties}" arg2="true" />
                  <then>
                    <fileReplaceAllPropertiesInZip file="@{resource}" dest="@{rootFolder}/@{configuration.tmp.location}/${configuration.tmp.filename}" filePattern="@{filePattern}" rezip="true" />
                  </then>
                  <else>
                    <copy file="@{resource}" tofile="@{rootFolder}/@{configuration.tmp.location}/${configuration.tmp.filename}" overwrite="true" />
                  </else>
                </if>
              </then>
            </elseif>
            <else>
              <fileGetSubPath basedir="@{basedir}" file="@{resource}" property="configuration.tmp.subdir" />
              <if>
                <equals arg1="${confMapper.replaceProperties}" arg2="true" />
                <then>
                  <fileReplaceAllProperties file="@{resource}" destFile="@{rootFolder}/@{configuration.tmp.location}/${configuration.tmp.subdir}/${configuration.tmp.filename}" filePattern="@{filePattern}" />
                </then>
                <else>
                  <copy file="@{resource}" tofile="@{rootFolder}/@{configuration.tmp.location}/${configuration.tmp.subdir}/${configuration.tmp.filename}" overwrite="true" />
                </else>
              </if>
            </else>
          </if>
        </sequential>
      </for>
    </sequential>
  </macrodef>

  <macrodef name="configurationCustomerMapper">
    <attribute name="resourceFolder" />
    <attribute name="resourceFileName" />
    <attribute name="resource" />
    <attribute name="resourceType" />

    <sequential>

      <propertyset id="configuration.tmp.patternDef">
        <propertyref regex="^configuration\.configurationCustomerMapper\..+\.pattern$" />
      </propertyset>

      <var name="configuration.tmp.resource" value="@{resource}" />

    </sequential>
  </macrodef>

  <macrodef name="configurationMapper">
    <attribute name="resourceFolder" />
    <attribute name="resourceFileName" />
    <attribute name="resource" />
    <attribute name="resourceType" />

    <sequential />
  </macrodef>

  <target name="create">
    <configurationSetup location="${configuration.location}" />
  </target>
</project>


text:
package deployclusterapplication

import (
	"github.com/astaxie/beego"
	"github.com/cloudawan/cloudone_gui/controllers/identity"
	"github.com/cloudawan/cloudone_utility/restclient"
)

type DeleteController struct {
	beego.Controller
}

// @Title delete
// @Description delete the cluster application deployment
// @Param clusterApplicationName path string true "The name of cluster application deployment"
// @Success 200 {string} {}
// @Failure 404 error reason
// @router /:clusterApplicationName [delete]
func (c *DeleteController) Delete() {
	clusterApplicationName := c.GetString(":clusterApplicationName")

	cloudoneProtocol := beego.AppConfig.String("cloudoneProtocol")
	cloudoneHost := beego.AppConfig.String("cloudoneHost")
	cloudonePort := beego.AppConfig.String("cloudonePort")

	namespace := c.GetSession("namespace").(string)

	url := cloudoneProtocol + "://" + cloudoneHost + ":" + cloudonePort +
		"/api/v1/deployclusterapplications/" + namespace + "/" + clusterApplicationName

	tokenHeaderMap, _ := c.GetSession("tokenHeaderMap").(map[string]string)

	_, err := restclient.RequestDelete(url, nil, tokenHeaderMap, true)

	if identity.IsTokenInvalidAndRedirect(c, c.Ctx, err) {
		return
	}

	if err != nil {
		// Error
		c.Data["json"] = make(map[string]interface{})
		c.Data["json"].(map[string]interface{})["error"] = err.Error()
		c.Ctx.Output.Status = 404
		c.ServeJSON()
		return
	} else {
		c.Data["json"] = make(map[string]interface{})
		c.ServeJSON()
	}
}


text:
namespace Voxel_core{
	using namespace std;

	typedef pair<unsigned int, float> G_H_cost;
	typedef pair<Indice3i, G_H_cost> Indice_cost_pair;
	typedef vector<Indice_cost_pair> Indice_cost_pair_list;

	struct OrderByCost
	{
		bool operator() (const Indice_cost_pair& a, const Indice_cost_pair& b) const
		{
			return (a.second.first + a.second.second) > (b.second.first + b.second.second);
		}
	};

	template<class _Ty,
	class _Container = vector<_Ty>,
	class _Pr = less<typename _Container::value_type> >
	class my_priority_queue : public std::priority_queue<_Ty,_Container,_Pr>
	{
	public:
		_Container getContainer() {
			return this->c;
		}
	};
	typedef my_priority_queue<Indice_cost_pair, vector<Indice_cost_pair>, OrderByCost> Indice_cost_pair_pqueue;

	//
	typedef vector<Indice_cost_pair> Indice_cost_pair_vector;
	typedef map<long, long> Indice_pair_map;
}


text:
CXX_SOURCES := nested.cpp

include Makefile.rules


text:
<TS language="gl" version="2.1">
<context>
    <name>AddressBookPage</name>
    <message>
        <source>Create a new address</source>
        <translation>Crear unha nova dirección</translation>
    </message>
    <message>
        <source>&New</source>
        <translation>&Novo</translation>
    </message>
    <message>
        <source>Copy the currently selected address to the system clipboard</source>
        <translation>Copiar a dirección seleccionada ao cartafol</translation>
    </message>
    <message>
        <source>&Copy</source>
        <translation>&Copiar</translation>
    </message>
    <message>
        <source>C&lose</source>
        <translation>&Pechar</translation>
    </message>
    <message>
        <source>Delete the currently selected address from the list</source>
        <translation>Borrar a dirección actualmente seleccionada da listaxe</translation>
    </message>
    <message>
        <source>Export the data in the current tab to a file</source>
        <translation>Exportar os datos da pestaña actual a un arquivo.</translation>
    </message>
    <message>
        <source>&Export</source>
        <translation>&Exportar</translation>
    </message>
    <message>
        <source>&Delete</source>
        <translation>&Borrar</translation>
    </message>
    </context>
<context>
    <name>AddressTableModel</name>
    </context>
<context>
    <name>AskPassphraseDialog</name>
    <message>
        <source>Passphrase Dialog</source>
        <translation>Diálogo de Contrasinal</translation>
    </message>
    <message>
        <source>Enter passphrase</source>
        <translation>Introduce contrasinal</translation>
    </message>
    <message>
        <source>New passphrase</source>
        <translation>Novo contrasinal</translation>
    </message>
    <message>
        <source>Repeat new passphrase</source>
        <translation>Repite novo contrasinal</translation>
    </message>
    </context>
<context>
    <name>BanTableModel</name>
    </context>
<context>
    <name>BitcoinGUI</name>
    <message>
        <source>Sign &message...</source>
        <translation>&Asinar mensaxe...</translation>
    </message>
    <message>
        <source>Synchronizing with network...</source>
        <translation>Sincronizando coa rede...</translation>
    </message>
    <message>
        <source>&Overview</source>
        <translation>&Vista xeral</translation>
    </message>
    <message>
        <source>Show general overview of wallet</source>
        <translation>Amosar vista xeral do moedeiro</translation>
    </message>
    <message>
        <source>&Transactions</source>
        <translation>&Transacciones</translation>
    </message>
    <message>
        <source>Browse transaction history</source>
        <translation>Navegar historial de transaccións</translation>
    </message>
    <message>
        <source>E&xit</source>
        <translation>&Saír</translation>
    </message>
    <message>
        <source>Quit application</source>
        <translation>Saír da aplicación</translation>
    </message>
    <message>
        <source>About &Qt</source>
        <translation>Acerca de &Qt</translation>
    </message>
    <message>
        <source>Show information about Qt</source>
        <translation>Amosar información acerca de Qt</translation>
    </message>
    <message>
        <source>&Options...</source>
        <translation>&Opcións...</translation>
    </message>
    <message>
        <source>&Encrypt Wallet...</source>
        <translation>&Encriptar Moedeiro...</translation>
    </message>
    <message>
        <source>&Backup Wallet...</source>
        <translation>Copia de &Seguridade do Moedeiro...</translation>
    </message>
    <message>
        <source>&Change Passphrase...</source>
        <translation>&Cambiar contrasinal...</translation>
    </message>
    <message>
        <source>&Receiving addresses...</source>
        <translation>Direccións para recibir</translation>
    </message>
    <message>
        <source>Reindexing blocks on disk...</source>
        <translation>Reindexando bloques no disco...</translation>
    </message>
    <message>
        <source>Backup wallet to another location</source>
        <translation>Facer copia de seguridade do moedeiro noutra localización</translation>
    </message>
    <message>
        <source>Change the passphrase used for wallet encryption</source>
        <translation>Cambiar o contrasinal empregado para a encriptación do moedeiro</translation>
    </message>
    <message>
        <source>Open debugging and diagnostic console</source>
        <translation>Abrir consola de depuración e diagnóstico</translation>
    </message>
    <message>
        <source>&Verify message...</source>
        <translation>&Verificar mensaxe...</translation>
    </message>
    <message>
        <source>Wallet</source>
        <translation>Moedeiro</translation>
    </message>
    <message>
        <source>&Send</source>
        <translation>&Enviar</translation>
    </message>
    <message>
        <source>&Receive</source>
        <translation>&Recibir</translation>
    </message>
    <message>
        <source>&Show / Hide</source>
        <translation>&Amosar/Agachar</translation>
    </message>
    <message>
        <source>Show or hide the main Window</source>
        <translation>Amosar ou agachar a ventana principal</translation>
    </message>
    <message>
        <source>Encrypt the private keys that belong to your wallet</source>
        <translation>Encriptar as claves privadas que pertencen ao teu moedeiro</translation>
    </message>
    <message>
        <source>&File</source>
        <translation>&Arquivo</translation>
    </message>
    <message>
        <source>&Settings</source>
        <translation>Axus&tes</translation>
    </message>
    <message>
        <source>&Help</source>
        <translation>A&xuda</translation>
    </message>
    <message>
        <source>Tabs toolbar</source>
        <translation>Barra de ferramentas</translation>
    </message>
    <message>
        <source>Show the list of used sending addresses and labels</source>
        <translation>Amosar a listaxe de direccións e etiquetas para enviar empregadas</translation>
    </message>
    <message>
        <source>Show the list of used receiving addresses and labels</source>
        <translation>Amosar a listaxe de etiquetas e direccións para recibir empregadas</translation>
    </message>
    <message>
        <source>&Command-line options</source>
        <translation>Opcións da liña de comandos</translation>
    </message>
    <message>
        <source>%1 behind</source>
        <translation>%1 detrás</translation>
    </message>
    <message>
        <source>Last received block was generated %1 ago.</source>
        <translation>O último bloque recibido foi xerado fai %1.</translation>
    </message>
    <message>
        <source>Transactions after this will not yet be visible.</source>
        <translation>As transaccións despois desta non serán todavía visibles.</translation>
    </message>
    <message>
        <source>Error</source>
        <translation>Erro</translation>
    </message>
    <message>
        <source>Warning</source>
        <translation>Precaución</translation>
    </message>
    <message>
        <source>Information</source>
        <translation>Información</translation>
    </message>
    <message>
        <source>Up to date</source>
        <translation>Actualizado</translation>
    </message>
    <message>
        <source>Catching up...</source>
        <translation>Poñendo ao día...</translation>
    </message>
    <message>
        <source>Sent transaction</source>
        <translation>Transacción enviada</translation>
    </message>
    <message>
        <source>Incoming transaction</source>
        <translation>Transacción entrante</translation>
    </message>
    <message>
        <source>Wallet is encrypted and currently unlocked</source>
        <translation>O moedeiro está encriptado e actualmente desbloqueado</translation>
    </message>
    <message>
        <source>Wallet is encrypted and currently locked</source>
        <translation>O moedeiro está encriptado e actualmente bloqueado</translation>
    </message>
    </context>
<context>
    <name>ClientModel</name>
    </context>
<context>
    <name>CoinControlDialog</name>
    <message>
        <source>Quantity:</source>
        <translation>Cantidade:</translation>
    </message>
    <message>
        <source>Bytes:</source>
        <translation>Bytes:</translation>
    </message>
    <message>
        <source>Amount:</source>
        <translation>Importe:</translation>
    </message>
    <message>
        <source>Fee:</source>
        <translation>Pago:</translation>
    </message>
    <message>
        <source>Change:</source>
        <translation>Cambiar:</translation>
    </message>
    <message>
        <source>(un)select all</source>
        <translation>(des)selecciona todo</translation>
    </message>
    <message>
        <source>Tree mode</source>
        <translation>Modo árbore</translation>
    </message>
    <message>
        <source>List mode</source>
        <translation>Modo lista</translation>
    </message>
    <message>
        <source>Amount</source>
        <translation>Cantidade</translation>
    </message>
    <message>
        <source>Date</source>
        <translation>Data</translation>
    </message>
    <message>
        <source>Confirmations</source>
        <translation>Confirmacións</translation>
    </message>
    <message>
        <source>Confirmed</source>
        <translation>Confirmado</translation>
    </message>
    </context>
<context>
    <name>DarksendConfig</name>
    </context>
<context>
    <name>EditAddressDialog</name>
    <message>
        <source>Edit Address</source>
        <translation>Modificar Dirección</translation>
    </message>
    <message>
        <source>&Label</source>
        <translation>&Etiqueta</translation>
    </message>
    <message>
        <source>The label associated with this address list entry</source>
        <translation>A etiqueta asociada con esta entrada da listaxe de direccións</translation>
    </message>
    <message>
        <source>The address associated with this address list entry. This can only be modified for sending addresses.</source>
        <translation>A dirección asociada con esta entrada na listaxe de dirección. Esta so pode ser modificada por direccións para enviar.</translation>
    </message>
    <message>
        <source>&Address</source>
        <translation>&Dirección</translation>
    </message>
    </context>
<context>
    <name>FreespaceChecker</name>
    <message>
        <source>A new data directory will be created.</source>
        <translation>Crearáse un novo directorio de datos.</translation>
    </message>
    <message>
        <source>name</source>
        <translation>nome</translation>
    </message>
    <message>
        <source>Directory already exists. Add %1 if you intend to create a new directory here.</source>
        <translation>O directorio xa existe. Engade %1 se queres crear un novo directorio aquí.</translation>
    </message>
    <message>
        <source>Path already exists, and is not a directory.</source>
        <translation>A ruta xa existe e non é un directorio.</translation>
    </message>
    <message>
        <source>Cannot create data directory here.</source>
        <translation>Non se pode crear directorio de datos aquí</translation>
    </message>
</context>
<context>
    <name>HelpMessageDialog</name>
    <message>
        <source>version</source>
        <translation>versión</translation>
    </message>
    <message>
        <source>Command-line options</source>
        <translation>Opcións da liña de comandos</translation>
    </message>
    <message>
        <source>Usage:</source>
        <translation>Emprego:</translation>
    </message>
    <message>
        <source>command-line options</source>
        <translation>opcións da liña de comandos</translation>
    </message>
    </context>
<context>
    <name>Intro</name>
    <message>
        <source>Welcome</source>
        <translation>Benvido</translation>
    </message>
    <message>
        <source>Use the default data directory</source>
        <translation>Empregar o directorio de datos por defecto</translation>
    </message>
    <message>
        <source>Use a custom data directory:</source>
        <translation>Empregar un directorio de datos personalizado</translation>
    </message>
    <message>
        <source>Error</source>
        <translation>Erro</translation>
    </message>
    </context>
<context>
    <name>MasternodeList</name>
    </context>
<context>
    <name>ModalOverlay</name>
    <message>
        <source>Form</source>
        <translation>Formulario</translation>
    </message>
    <message>
        <source>Last block time</source>
        <translation>Hora do último bloque</translation>
    </message>
    </context>
<context>
    <name>OpenURIDialog</name>
    <message>
        <source>Open URI</source>
        <translation>Abrir URI</translation>
    </message>
    <message>
        <source>Open payment request from URI or file</source>
        <translation>Abrir solicitude de pago dende URI ou ficheiro</translation>
    </message>
    <message>
        <source>URI:</source>
        <translation>URI:</translation>
    </message>
    <message>
        <source>Select payment request file</source>
        <translation>Seleccionar ficheiro de solicitude de pago</translation>
    </message>
    </context>
<context>
    <name>OptionsDialog</name>
    <message>
        <source>Options</source>
        <translation>Opcións</translation>
    </message>
    <message>
        <source>&Main</source>
        <translation>&Principal</translation>
    </message>
    <message>
        <source>Reset all client options to default.</source>
        <translation>Restaurar todas as opcións de cliente ás por defecto</translation>
    </message>
    <message>
        <source>&Reset Options</source>
        <translation>Opcións de &Restaurar</translation>
    </message>
    <message>
        <source>&Network</source>
        <translation>&Rede</translation>
    </message>
    <message>
        <source>W&allet</source>
        <translation>Moedeiro</translation>
    </message>
    <message>
        <source>Map port using &UPnP</source>
        <translation>Mapear porto empregando &UPnP</translation>
    </message>
    <message>
        <source>Proxy &IP:</source>
        <translation>&IP do Proxy:</translation>
    </message>
    <message>
        <source>&Port:</source>
        <translation>&Porto:</translation>
    </message>
    <message>
        <source>Port of the proxy (e.g. 9050)</source>
        <translation>Porto do proxy (exemplo: 9050)</translation>
    </message>
    <message>
        <source>&Window</source>
        <translation>&Xanela</translation>
    </message>
    <message>
        <source>Show only a tray icon after minimizing the window.</source>
        <translation>Amosar so un icono na bandexa tras minimiza-la xanela.</translation>
    </message>
    <message>
        <source>&Minimize to the tray instead of the taskbar</source>
        <translation>&Minimizar á bandexa en lugar de á barra de tarefas.</translation>
    </message>
    <message>
        <source>M&inimize on close</source>
        <translation>M&inimizar ao pechar</translation>
    </message>
    <message>
        <source>&Display</source>
        <translation>&Visualización</translation>
    </message>
    <message>
        <source>User Interface &language:</source>
        <translation>&Linguaxe de interface de usuario:</translation>
    </message>
    <message>
        <source>&Unit to show amounts in:</source>
        <translation>&Unidade na que amosar as cantidades:</translation>
    </message>
    <message>
        <source>Choose the default subdivision unit to show in the interface and when sending coins.</source>
        <translation>Escolle a unidade de subdivisión por defecto para amosar na interface e ao enviar moedas.</translation>
    </message>
    <message>
        <source>&OK</source>
        <translation>&OK</translation>
    </message>
    <message>
        <source>&Cancel</source>
        <translation>&Cancelar</translation>
    </message>
    <message>
        <source>default</source>
        <translation>por defecto</translation>
    </message>
    <message>
        <source>Confirm options reset</source>
        <translation>Confirmar opcións de restaurar</translation>
    </message>
    <message>
        <source>Error</source>
        <translation>Erro</translation>
    </message>
    <message>
        <source>The supplied proxy address is invalid.</source>
        <translation>A dirección de proxy suministrada é inválida.</translation>
    </message>
</context>
<context>
    <name>OverviewPage</name>
    <message>
        <source>Form</source>
        <translation>Formulario</translation>
    </message>
    <message>
        <source>Your current spendable balance</source>
        <translation>O teu balance actualmente dispoñible</translation>
    </message>
    <message>
        <source>Total of transactions that have yet to be confirmed, and do not yet count toward the spendable balance</source>
        <translation>Total de transaccións que aínda teñen que ser confirmadas, e non contan todavía dentro do balance gastable</translation>
    </message>
    <message>
        <source>Immature:</source>
        <translation>Inmaduro:</translation>
    </message>
    <message>
        <source>Mined balance that has not yet matured</source>
        <translation>O balance minado todavía non madurou</translation>
    </message>
    <message>
        <source>Total:</source>
        <translation>Total:</translation>
    </message>
    <message>
        <source>Your current total balance</source>
        <translation>O teu balance actual total</translation>
    </message>
    </context>
<context>
    <name>PaymentServer</name>
    </context>
<context>
    <name>PeerTableModel</name>
    </context>
<context>
    <name>ProposalList</name>
    </context>
<context>
    <name>ProposalTableModel</name>
    </context>
<context>
    <name>QObject</name>
    <message>
        <source>Amount</source>
        <translation>Cantidade</translation>
    </message>
    <message>
        <source>%1 h</source>
        <translation>%1 h</translation>
    </message>
    <message>
        <source>%1 m</source>
        <translation>%1 m</translation>
    </message>
    <message>
        <source>N/A</source>
        <translation>N/A</translation>
    </message>
    <message>
        <source>%1 B</source>
        <translation>%1 B</translation>
    </message>
    <message>
        <source>%1 KB</source>
        <translation>%1 KB</translation>
    </message>
    <message>
        <source>%1 MB</source>
        <translation>%1 MB</translation>
    </message>
    <message>
        <source>%1 GB</source>
        <translation>%1 GB</translation>
    </message>
    <message>
        <source>unknown</source>
        <translation>descoñecido</translation>
    </message>
</context>
<context>
    <name>QObject::QObject</name>
    </context>
<context>
    <name>QRDialog</name>
    </context>
<context>
    <name>QRGeneralImageWidget</name>
    </context>
<context>
    <name>QRImageWidget</name>
    </context>
<context>
    <name>RPCConsole</name>
    <message>
        <source>N/A</source>
        <translation>N/A</translation>
    </message>
    <message>
        <source>Client version</source>
        <translation>Versión do cliente</translation>
    </message>
    <message>
        <source>&Information</source>
        <translation>&Información</translation>
    </message>
    <message>
        <source>Startup time</source>
        <translation>Tempo de arranque</translation>
    </message>
    <message>
        <source>Network</source>
        <translation>Rede</translation>
    </message>
    <message>
        <source>Number of connections</source>
        <translation>Número de conexións</translation>
    </message>
    <message>
        <source>Block chain</source>
        <translation>Cadea de bloques</translation>
    </message>
    <message>
        <source>Current number of blocks</source>
        <translation>Número actual de bloques</translation>
    </message>
    <message>
        <source>Last block time</source>
        <translation>Hora do último bloque</translation>
    </message>
    <message>
        <source>&Open</source>
        <translation>&Abrir</translation>
    </message>
    <message>
        <source>&Console</source>
        <translation>&Consola</translation>
    </message>
    <message>
        <source>&Network Traffic</source>
        <translation>&Tráfico de Rede</translation>
    </message>
    <message>
        <source>Totals</source>
        <translation>Totais</translation>
    </message>
    <message>
        <source>In:</source>
        <translation>Dentro:</translation>
    </message>
    <message>
        <source>Out:</source>
        <translation>Fóra:</translation>
    </message>
    <message>
        <source>Debug log file</source>
        <translation>Arquivo de log de depuración</translation>
    </message>
    <message>
        <source>Clear console</source>
        <translation>Limpar consola</translation>
    </message>
    </context>
<context>
    <name>ReceiveCoinsDialog</name>
    <message>
        <source>&Amount:</source>
        <translation>&Cantidade:</translation>
    </message>
    <message>
        <source>&Label:</source>
        <translation>&Etiqueta:</translation>
    </message>
    <message>
        <source>&Message:</source>
        <translation>&Mensaxe:</translation>
    </message>
    <message>
        <source>Clear all fields of the form.</source>
        <translation>Limpar tódolos campos do formulario</translation>
    </message>
    <message>
        <source>Clear</source>
        <translation>Limpar</translation>
    </message>
    <message>
        <source>&Request payment</source>
        <translation>&Solicitar pago</translation>
    </message>
    </context>
<context>
    <name>ReceiveRequestDialog</name>
    <message>
        <source>QR Code</source>
        <translation>Código QR</translation>
    </message>
    <message>
        <source>Copy &URI</source>
        <translation>Copiar &URI</translation>
    </message>
    <message>
        <source>Copy &Address</source>
        <translation>Copiar &Dirección</translation>
    </message>
    <message>
        <source>&Save Image...</source>
        <translation>&Gardar Imaxe...</translation>
    </message>
    </context>
<context>
    <name>RecentRequestsTableModel</name>
    </context>
<context>
    <name>SendCoinsDialog</name>
    <message>
        <source>Send Coins</source>
        <translation>Moedas Enviadas</translation>
    </message>
    <message>
        <source>Insufficient funds!</source>
        <translation>Fondos insuficientes</translation>
    </message>
    <message>
        <source>Quantity:</source>
        <translation>Cantidade:</translation>
    </message>
    <message>
        <source>Bytes:</source>
        <translation>Bytes:</translation>
    </message>
    <message>
        <source>Amount:</source>
        <translation>Importe:</translation>
    </message>
    <message>
        <source>Fee:</source>
        <translation>Pago:</translation>
    </message>
    <message>
        <source>Change:</source>
        <translation>Cambiar:</translation>
    </message>
    <message>
        <source>Transaction Fee:</source>
        <translation>Tarifa de transacción:</translation>
    </message>
    <message>
        <source>Send to multiple recipients at once</source>
        <translation>Enviar a múltiples receptores á vez</translation>
    </message>
    <message>
        <source>Add &Recipient</source>
        <translation>Engadir &Receptor</translation>
    </message>
    <message>
        <source>Clear all fields of the form.</source>
        <translation>Limpar tódolos campos do formulario</translation>
    </message>
    <message>
        <source>Clear &All</source>
        <translation>Limpar &Todo</translation>
    </message>
    <message>
        <source>Balance:</source>
        <translation>Balance:</translation>
    </message>
    <message>
        <source>Confirm the send action</source>
        <translation>Confirmar a acción de envío</translation>
    </message>
    <message>
        <source>S&end</source>
        <translation>&Enviar</translation>
    </message>
    </context>
<context>
    <name>SendCoinsEntry</name>
    <message>
        <source>A&mount:</source>
        <translation>&Cantidade:</translation>
    </message>
    <message>
        <source>Pay &To:</source>
        <translation>Pagar &A:</translation>
    </message>
    <message>
        <source>&Label:</source>
        <translation>&Etiqueta:</translation>
    </message>
    <message>
        <source>Choose previously used address</source>
        <translation>Escoller dirección previamente empregada</translation>
    </message>
    <message>
        <source>This is a normal payment.</source>
        <translation>Este é un pago normal</translation>
    </message>
    <message>
        <source>Alt+A</source>
        <translation>Alt+A</translation>
    </message>
    <message>
        <source>Paste address from clipboard</source>
        <translation>Pegar dirección dende portapapeis</translation>
    </message>
    <message>
        <source>Alt+P</source>
        <translation>Alt+P</translation>
    </message>
    <message>
        <source>Remove this entry</source>
        <translation>Eliminar esta entrada</translation>
    </message>
    <message>
        <source>Message:</source>
        <translation>Mensaxe:</translation>
    </message>
    <message>
        <source>Enter a label for this address to add it to the list of used addresses</source>
        <translation>Introduce unha etiqueta para esta dirección para engadila á listaxe de direccións empregadas</translation>
    </message>
    <message>
        <source>Pay To:</source>
        <translation>Pagar A:</translation>
    </message>
    <message>
        <source>Memo:</source>
        <translation>Memo:</translation>
    </message>
    </context>
<context>
    <name>SendConfirmationDialog</name>
    </context>
<context>
    <name>ShutdownWindow</name>
    </context>
<context>
    <name>SignVerifyMessageDialog</name>
    <message>
        <source>Signatures - Sign / Verify a Message</source>
        <translation>Sinaturas - Asinar / Verificar unha Mensaxe</translation>
    </message>
    <message>
        <source>&Sign Message</source>
        <translation>&Asinar Mensaxe</translation>
    </message>
    <message>
        <source>Choose previously used address</source>
        <translation>Escoller dirección previamente empregada</translation>
    </message>
    <message>
        <source>Alt+A</source>
        <translation>Alt+A</translation>
    </message>
    <message>
        <source>Paste address from clipboard</source>
        <translation>Pegar dirección dende portapapeis</translation>
    </message>
    <message>
        <source>Alt+P</source>
        <translation>Alt+P</translation>
    </message>
    <message>
        <source>Enter the message you want to sign here</source>
        <translation>Introduce a mensaxe que queres asinar aquí</translation>
    </message>
    <message>
        <source>Signature</source>
        <translation>Sinatura</translation>
    </message>
    <message>
        <source>Copy the current signature to the system clipboard</source>
        <translation>Copiar a sinatura actual ao portapapeis do sistema</translation>
    </message>
    <message>
        <source>Sign &Message</source>
        <translation>Asinar &Mensaxe</translation>
    </message>
    <message>
        <source>Reset all sign message fields</source>
        <translation>Restaurar todos os campos de sinatura de mensaxe</translation>
    </message>
    <message>
        <source>Clear &All</source>
        <translation>Limpar &Todo</translation>
    </message>
    <message>
        <source>&Verify Message</source>
        <translation>&Verificar Mensaxe</translation>
    </message>
    <message>
        <source>Verify &Message</source>
        <translation>Verificar &Mensaxe</translation>
    </message>
    <message>
        <source>Reset all verify message fields</source>
        <translation>Restaurar todos os campos de verificación de mensaxe</translation>
    </message>
    </context>
<context>
    <name>SplashScreen</name>
    <message>
        <source>[testnet]</source>
        <translation>[testnet]</translation>
    </message>
    </context>
<context>
    <name>TrafficGraphWidget</name>
    <message>
        <source>KB/s</source>
        <translation>KB/s</translation>
    </message>
</context>
<context>
    <name>TransactionDesc</name>
    </context>
<context>
    <name>TransactionDescDialog</name>
    <message>
        <source>This pane shows a detailed description of the transaction</source>
        <translation>Este panel amosa unha descripción detallada da transacción</translation>
    </message>
</context>
<context>
    <name>TransactionTableModel</name>
    </context>
<context>
    <name>TransactionView</name>
    </context>
<context>
    <name>UnitDisplayStatusBarControl</name>
    </context>
<context>
    <name>WalletFrame</name>
    </context>
<context>
    <name>WalletModel</name>
    </context>
<context>
    <name>WalletView</name>
    </context>
<context>
    <name>chaincoin-core</name>
    </context>
</TS>


text:
package redbot

import better.files._
import redbot.bots.{CuteBot, FeedBot, RedBot, CrushBot}
import redbot.discord.impl.d4j.D4JClient
import redbot.utils.Logger

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Future, blocking}

object Main {
  def main(args: Array[String]): Unit = {

    val tokenRegex = "(.+?)\\s+(.+)".r
    val tokens = (File.currentWorkingDirectory / "configs" / "tokens.txt").lines
      .flatMap(tokenRegex.findFirstMatchIn).map(m => m.group(1) -> m.group(2)).toMap

    val botTokens = Seq(
      //{RedBot.apply _} -> "test",
      //{FeedBot.apply _} -> "feed",
      //{CuteBot.apply _} -> "cute",
      {CrushBot.apply _} -> "crush"
    )

    val bots = botTokens.flatMap { case (constr, name) =>
      tokens.get(name).orElse(throw new RuntimeException(s"Missing token for $name."))
        .map { t => constr(new D4JClient(t)) }
    }

    bots.foreach { bot =>
      Future {
        Logger.info("Logging in bot " + bot.getClass.getSimpleName)
        blocking { bot.client.login() }
      }
    }

    // Wait for Ctrl+D (EOF) in command line
    Scanner.stdin.foreach {
      case x if x.exists(_ == EOF) =>
        Logger.info("Exiting JVM now")

        System.exit(0)
    }
  }
}