text:
NS_ASSUME_NONNULL_BEGIN

NSString * const kALInMemoryDBPath = @":memory:";  // in-memory db
NSString * const kALTempDBPath     = @":temp:";    // temp db;

static AL_FORCE_INLINE NSMutableDictionary<NSString *, ALDatabase *> *openingDatabaseDict() {
    static NSMutableDictionary *dict = nil;

    if (dict == nil) {
        al_static_gcd_semaphore_def(localSem, 1);
        with_gcd_semaphore(localSem, DISPATCH_TIME_FOREVER, ^{
            if (dict == nil) {
                dict = [NSMutableDictionary dictionary];
            }
        });
    }
    return dict;
}

static AL_FORCE_INLINE dispatch_semaphore_t openingDBDictSemaphore() {
    static dispatch_semaphore_t sema = NULL;

    if (sema == NULL) {
        al_static_gcd_semaphore_def(localSem, 1);
        with_gcd_semaphore(localSem, DISPATCH_TIME_FOREVER, ^{
            if (sema == NULL) {
                sema = dispatch_semaphore_create(1);
            }
        });
    }
    return sema;
}

@implementation ALDatabase {
    BOOL               _dbFileExisted;
    NSInteger          _openFlags;
    id<ALDBConnectionProtocol> _openHelper;

    BOOL               _enableDebug;

}

#pragma mark - database manager
+ (nullable instancetype)databaseWithPath:(NSString *)path {
    path = al_stringValue(path);
    if (path == nil) {
        return nil;
    }

    NSString *cachedKey = [self cachedKeyWithPath:path readonly:NO];
    NSMutableDictionary *cacheDict = openingDatabaseDict();
    __block ALDatabase *db = cacheDict[cachedKey];
    if (db == nil) {
        with_gcd_semaphore(openingDBDictSemaphore(), DISPATCH_TIME_FOREVER, ^{
            db = cacheDict[cachedKey];
            if (db == nil) {
                // @see "+[FMDatabase databaseWithPath:]",  @"" => temp DB; nil => in-memory DB
                db = [(ALDatabase *) [self alloc] initWithPath:[self innerDBFilePathWithPath:path]
                                                         flags:SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE];
                if (db != nil) {
                    cacheDict[cachedKey] = db;
                }
            }
        });
    }
    return db;
}

// database opened in readonly mode.
+ (nullable instancetype)readonlyDatabaseWithPath:(NSString *)path {
    NSString *cachedKey = [self cachedKeyWithPath:path readonly:YES];
    __block ALDatabase *readonlyDB = openingDatabaseDict()[cachedKey];
    if (readonlyDB == nil) {
        al_static_gcd_semaphore_def(localSema, 1);
        with_gcd_semaphore(localSema, DISPATCH_TIME_FOREVER, ^{
            readonlyDB = openingDatabaseDict()[cachedKey];
            if (readonlyDB != nil) {
                return;
            }

            BOOL isDir = NO;
            if ([[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir] && !isDir) {
                if ([self databaseWithPath:path]) { // make sure to create & migrate database
                    readonlyDB = [(ALDatabase *)[self alloc] initWithPath:[self innerDBFilePathWithPath:path]
                                                                    flags:SQLITE_OPEN_READONLY];
                    if (readonlyDB != nil) {
                        with_gcd_semaphore(openingDBDictSemaphore(), DISPATCH_TIME_FOREVER, ^{
                            openingDatabaseDict()[cachedKey] = readonlyDB;
                        });
                    }
                }
            } else {
                // database not yet created, ignore.
                readonlyDB = nil;
                return;
            }
        });
    }
    return readonlyDB;
}

// database opened in readonly mode, and bind to caller's thread local
+ (nullable instancetype)threadLocalReadonlyDatabaseWithPath:(NSString *)path {
    NSMutableDictionary *dict = [NSThread currentThread].threadDictionary;
    NSString *cachedKey = [self cachedKeyWithPath:path readonly:YES];
    cachedKey = [@"ALDatabase:" stringByAppendingString:cachedKey];
    __block ALDatabase *localReadonlyDB = dict[cachedKey];
    if (localReadonlyDB == nil) {
        al_static_gcd_semaphore_def(localSema, 1);
        with_gcd_semaphore(localSema, DISPATCH_TIME_FOREVER, ^{
            localReadonlyDB = dict[cachedKey];
            if (localReadonlyDB != nil) {
                return;
            }

            BOOL isDir = NO;
            if ([[NSFileManager defaultManager] fileExistsAtPath:path isDirectory:&isDir] && !isDir) {
                if ([self databaseWithPath:path]) { // make sure to create & migrate database
                    localReadonlyDB = [(ALDatabase *)[self alloc] initWithPath:[self innerDBFilePathWithPath:path]
                                                                         flags:SQLITE_OPEN_READONLY];
                    if (localReadonlyDB != nil) {
                        dict[cachedKey] = localReadonlyDB;
                    }
                }
            } else {
                // database not yet created, ignore.
                localReadonlyDB = nil;
                return;
            }
        });
    }
    return localReadonlyDB;
}

// openFlag: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
- (nullable instancetype)initWithPath:(nullable NSString *)path flags:(int)openFlags{

    if (!al_isEmptyString(path)) {

        NSError *tmpError = nil;
        if (![[NSFileManager defaultManager] createDirectoryAtPath:[path stringByDeletingLastPathComponent]
                                       withIntermediateDirectories:YES
                                                        attributes:nil
                                                             error:&tmpError]) {
            ALLogError(@"Can not create database file:%@; %@", path, tmpError);
            return nil;
        }
    }

    self = [super init];
    if (self) {
#if DEBUG
        _enableDebug = YES;
#else
        _enableDebug = NO;
#endif
        // for compatible.
        // if the original database existed and did not set the version information,
        // we need to make a distinction between 'database not exists' and 'database version = 0'
        _dbFileExisted = [[NSFileManager defaultManager] fileExistsAtPath:path];

        _queue = [[ALFMDatabaseQueue alloc] initWithPath:path flags:openFlags];
        if (![self open]) {
            ALLogError(@"Open database error or migrate database failed. path: %@", path);
            self = nil;
        }
        _openFlags = openFlags;
        _openHelper = [self connectionHandler];
    }
    return self;
}

- (void)dealloc {
    [self close];
}

// To support chain expression syntax, we need to support default -init constructor that we can
// create a "fake" object to avoid crash. -- Think about "nil();".
//- (nullable instancetype)init {
//    return nil;
//}

- (BOOL)isReadonly {
    return (_openFlags & SQLITE_OPEN_READONLY) == SQLITE_OPEN_READONLY;
}

+ (NSString *)innerDBFilePathWithPath:(NSString *)path {
    NSString *dbFilePath = path;
    if ([path isEqualToString:kALInMemoryDBPath]) {
        dbFilePath = nil;
    } else if ([path isEqualToString:kALTempDBPath]) {
        dbFilePath = @"";
    }
    return dbFilePath;
}

+ (NSString *)cachedKeyWithPath:(NSString *)path readonly:(BOOL)readonly {
    NSParameterAssert(path != nil);

    NSString *key = al_stringOrEmpty(path);
    if (readonly) {
        key = [key stringByAppendingString:@"#readonly"];
    }
    return key;
}

- (NSString *)cachedKey {
    return [self.class cachedKeyWithPath:_queue.path readonly:self.readonly];
}

- (BOOL)open {
    if (_queue == nil) {
        return NO;
    }

    __block BOOL ret = YES;
    [_queue inDatabase:^(FMDatabase * _Nonnull db) {
        [db closeOpenResultSets];

        // extension point: you can define some specified configs immediately after DB opened。
        if ([_openHelper respondsToSelector:@selector(databaseDidOpen:)]) {
            [_openHelper databaseDidOpen:db];
        }

        // database migration
        if (![self isReadonly]) {
            ret = [self migrateDatabase:db];
        }

        // extension point
        if ([_openHelper respondsToSelector:@selector(databaseDidReady:)]) {
            [_openHelper databaseDidReady:db];
        }
    }];

    return ret;
}

- (BOOL)migrateDatabase:(FMDatabase *)db {
    id<ALDBMigrationProtocol> migrationProcessor = [self dbMigrationProcessor];

    if (migrationProcessor == nil) {
        _ALDBLog(@"Not found database migration processor, try auto-migration. database path: %@", _queue.path);

        if (!_dbFileExisted) {
            [ALDBMigrationHelper setupDatabase:db];
        } else {
            [ALDBMigrationHelper autoMigrateDatabase:db];
        }
        return YES;
    } else {

        // all the database version should begins from 1 (DO NOT begins from 0 !!!)
        NSInteger newVersion = [migrationProcessor currentVersion];
        al_guard_or_return1(newVersion > 0, NO, @"*** Database version must be > 0, but was %d", (int)newVersion);

        if (!_dbFileExisted) { // create database directly
            BOOL created = NO;
            if ([migrationProcessor respondsToSelector:@selector(setupDatabase:)]) { // manually setup database
                created = [migrationProcessor setupDatabase:db];
            } else {
                [ALDBMigrationHelper setupDatabase:db];
                created = YES;
            }

            al_guard_or_return1(created, NO, @"Can not setup database at path: %@", _queue.path);
            return [self updateDatabaseVersion:newVersion dbHandler:db];
        } else {
            NSInteger dbVersion = [db intForQuery:@"PRAGMA user_version;"];

            if (dbVersion < newVersion) {
                if (![migrationProcessor database:db upgradeFromVersion:dbVersion to:newVersion] ) {
                    ALAssert(NO, @"migrate from version %@ to %@ failed!!! database: %@", @(dbVersion),
                             @(newVersion), _queue.path);
                    return NO;
                }
                return [self updateDatabaseVersion:newVersion dbHandler:db];
            } else if (dbVersion > newVersion) {
                if (![migrationProcessor database:db downgradeFromVersion:dbVersion to:newVersion] ) {
                    ALAssert(NO, @"migrate from version %@ to %@ failed!!! database: %@", @(dbVersion),
                             @(newVersion), _queue.path);
                    return NO;
                }
                return [self updateDatabaseVersion:newVersion dbHandler:db];
            }
        }
    }
    return YES;
}

- (BOOL)updateDatabaseVersion:(NSInteger)version dbHandler:(FMDatabase *)db {
    return [ALDBMigrationHelper executeSQL:[NSString stringWithFormat:@"PRAGMA user_version=%ld;", (long)version]
                                  database:db];
}

- (void)close {
    if (_queue == nil) {
        return;
    }

    with_gcd_semaphore(openingDBDictSemaphore(), DISPATCH_TIME_FOREVER, ^{
        if (_queue == nil) {
            return;
        }

        // extension point
        [_queue inDatabase:^(FMDatabase * _Nonnull db) {
            if ([_openHelper respondsToSelector:@selector(databaseWillClose:)]) {
                [_openHelper databaseWillClose:db];
            }
        }];

        NSString *key = [self cachedKey];
        if (key != nil) {
            [openingDatabaseDict() removeObjectForKey:key];
        }
        [_queue close];

        // extension point
        if ([_openHelper respondsToSelector:@selector(databaseWithPathDidClose:)]) {
            [_openHelper databaseWithPathDidClose:_queue.path];
        }

        _queue = nil;
    });
}

- (id)copy {
    return self;
}

- (id)mutableCopy {
    return self;
}

- (nullable id<ALDBMigrationProtocol>)dbMigrationProcessor {
    Class cls = [[ALOCRuntime classConfirmsToProtocol:@protocol(ALDBMigrationProtocol)] bk_select:^BOOL(Class cls){
        return [cls canMigrateDatabaseWithPath:_queue.path];
    }].anyObject;
    return [[cls alloc] init];
}

- (nullable id<ALDBConnectionProtocol>)connectionHandler {
    Class cls = [[ALOCRuntime classConfirmsToProtocol:@protocol(ALDBConnectionProtocol)] bk_select:^BOOL(Class cls){
        return [cls canHandleDatabaseWithPath:_queue.path];
    }].anyObject;
    return [[cls alloc] init];
}

@end

#define __ALDB_STMT_INIT(stmt_class) \
    stmt_class *stmt = nil;                                             \
    if (al_objIsValidBlocksChainObject(self)) {                         \
        stmt = [[stmt_class alloc] init];                               \
        [stmt bindDatabase:self];                                       \
    }

#define __ALDB_STMT_BLOCK_ID_ARG(stmt_class, block_args, prop_name)         \
- (stmt_class * (^)(id block_args))prop_name {                              \
    return ^stmt_class *(id block_args) {                                   \
        __ALDB_STMT_INIT(stmt_class);                                       \
        return al_safeBlocksChainObj(stmt, stmt_class).prop_name(block_args);  \
    };                                                                      \
}

#define __ALDB_STMT_BLOCK(stmt_class, prop_name)                            \
- (stmt_class * (^)())prop_name {                                           \
    return ^stmt_class * {                                                  \
        __ALDB_STMT_INIT(stmt_class);                                       \
        return al_safeBlocksChainObj(stmt, stmt_class).prop_name();         \
    };                                                                      \
}

@implementation ALDatabase (ALSQLStatment)

__ALDB_STMT_BLOCK_ID_ARG(ALSQLSelectStatement, columns, SELECT);

__ALDB_STMT_BLOCK_ID_ARG(ALSQLUpdateStatement, tableName, UPDATE);

__ALDB_STMT_BLOCK(ALSQLInsertStatement, INSERT);
__ALDB_STMT_BLOCK(ALSQLInsertStatement, REPLACE);

__ALDB_STMT_BLOCK(ALSQLDeleteStatement, DELETE);

@end

@implementation ALDatabase (ALDebug)

- (void)setEnableDebug:(BOOL)enableDebug {
    _enableDebug = enableDebug;
}

- (BOOL)enableDebug {
    return _enableDebug;
}

@end

NS_ASSUME_NONNULL_END


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">
    <TextView
        android:id="@+id/on_demand_kotlin_text_view"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/on_demand_kotlin_text"/>
</LinearLayout>

redpajama_set_name: RedPajamaGithub


text:
package org.neo4j.graphalgo.centrality;

import static org.junit.Assert.assertTrue;

import org.junit.Test;
import org.neo4j.graphalgo.CostEvaluator;
import org.neo4j.graphalgo.impl.centrality.NetworkRadius;
import org.neo4j.graphalgo.impl.shortestpath.SingleSourceShortestPath;
import org.neo4j.graphalgo.impl.shortestpath.SingleSourceShortestPathDijkstra;
import org.neo4j.graphalgo.impl.util.DoubleComparator;
import org.neo4j.graphdb.Direction;
import org.neo4j.graphdb.Relationship;

import common.Neo4jAlgoTestCase;

public class NetworkRadiusTest extends Neo4jAlgoTestCase
{
    protected SingleSourceShortestPath<Double> getSingleSourceShortestPath()
    {
        return new SingleSourceShortestPathDijkstra<Double>( 0.0, null,
            new CostEvaluator<Double>()
            {
                public Double getCost( Relationship relationship,
                            Direction direction )
                {
                    return 1.0;
                }
            }, new org.neo4j.graphalgo.impl.util.DoubleAdder(),
            new org.neo4j.graphalgo.impl.util.DoubleComparator(),
            Direction.BOTH, MyRelTypes.R1 );
    }

    @Test
    public void testBox()
    {
        graph.makeEdgeChain( "a,b,c,d,a" );
        NetworkRadius<Double> radius = new NetworkRadius<Double>(
            getSingleSourceShortestPath(), 0.0, graph.getAllNodes(),
            new DoubleComparator() );
        assertTrue( radius.getCentrality( null ) == 2.0 );
    }

    @Test
    public void testPlusShape()
    {
        graph.makeEdgeChain( "a,b,c" );
        graph.makeEdgeChain( "d,b,e" );
        NetworkRadius<Double> radius = new NetworkRadius<Double>(
            getSingleSourceShortestPath(), 0.0, graph.getAllNodes(),
            new DoubleComparator() );
        assertTrue( radius.getCentrality( null ) == 1.0 );
    }

    @Test
    public void testChain()
    {
        graph.makeEdgeChain( "a,b,c,d,e" );
        NetworkRadius<Double> radius = new NetworkRadius<Double>(
            getSingleSourceShortestPath(), 0.0, graph.getAllNodes(),
            new DoubleComparator() );
        assertTrue( radius.getCentrality( null ) == 2.0 );
    }
}


text:
require_relative 'extendings.rb'
require_relative 'symbol.rb'
require_relative 'array.rb'


text:
package org.odlabs.wiquery.ui.button;

import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.WebPage;

/**
 * $Id: ButtonPageFailedTestPage.java 565 2010-11-22 08:52:43Z hielke.hoeve@gmail.com $
 * <p>
 * Dummy page to test the onComponent of the ButtonBehavior
 * </p>
 *
 * @author Julien Roche
 * @since 1.1
 */
public class ButtonPageFailedTestPage extends WebPage {
	public ButtonPageFailedTestPage() {
		super();
		add(new WebMarkupContainer("failedButton").add(new ButtonBehavior()));
	}
}


text:
package ast;

/**
 * @author GAO RISHENG A0101891L
 * This class is mainly in charge of construction syntax for statements that only consists
 * 1 expression in C Program
 *
 */
public final class ASTExpressionStatementC extends ASTExpressionStatement {
	public ASTExpressionStatementC(ASTExpression p) {
		super(p);

	}

	public String toSyntax(){
		this.result = this.exp.toSyntax()+";\n";
		return this.result;
	}
}


text:
'use strict';

const path = require('path');
const ExtractTextPlugin = require('extract-text-webpack-plugin');
const templateFn = require('adjust-sourcemap-loader').moduleFilenameTemplate({format: 'projectRelative'});

const extractSass = new ExtractTextPlugin({
  filename: '[name].[contenthash].css',
  disable: false,
  allChunks: true
});

module.exports = {
  entry: path.join(__dirname, process.env.ENTRY),
  output: {
    path: path.join(__dirname, process.env.OUTPUT),
    filename: '[name].js',
    devtoolModuleFilenameTemplate: templateFn,
    devtoolFallbackModuleFilenameTemplate: templateFn
  },
  devtool: JSON.parse(process.env.DEVTOOL),
  resolve: {
    modules: [path.join(__dirname, 'modules'), 'node_modules'] // specifically for isolation in module-relative test
  },
  module: {
    rules: [{
      test: /\.scss$/,
      use: extractSass.extract({
        use: [
          {
            loader: 'css-loader',
            options: JSON.parse(process.env.CSS_OPTIONS)
          }, {
            loader: 'resolve-url-loader',
            options: Object.assign(JSON.parse(process.env.LOADER_OPTIONS), {
              join: process.env.LOADER_JOIN ?
                new Function('require', process.env.LOADER_JOIN)(require) : // jshint ignore:line
                undefined
            })
          }, {
            loader: 'sass-loader',
            options: {
              sourceMap: true,
              sourceMapContents: false
            }
          }
        ]
      })
    }, {
      test: /\.(woff2?|ttf|eot|svg|jpg)(?:[?#].+)?$/,
      use: [{
        loader: 'file-loader'
      }]
    }]
  },
  plugins: [
    extractSass
  ]
};


text:
package com.problems.test;

import com.problems.MergeTwoArraysSatisfyingGivenConstraints;
import junit.framework.Assert;
import org.junit.Test;

/**
 * Created by Maks on 4/20/2017.
 */
public class MergeTwoArraysSatisfyingGivenConstraintsTest {

    @Test
    public void TestSolution1Case1(){
        MergeTwoArraysSatisfyingGivenConstraints s=new MergeTwoArraysSatisfyingGivenConstraints();
        Integer[] a=new Integer[]{ 0, 2, 0, 3, 0, 5, 6, 0, 0};
        Integer[] b=new Integer[]{1, 8, 9, 10, 15};
        s.solution1(a,b);
        Integer[] expected =new Integer[]{1, 2, 3, 5, 6, 8, 9, 10, 15};
        for(int i=0; i<expected.length; i++){
            Assert.assertEquals(expected[i],a[i]);
        }

    }
}


text:
package com.tlorrain.android.rezenerator.core.utils;

import java.io.File;

import org.fest.assertions.Assertions;
import org.junit.Test;

import com.tlorrain.android.rezenerator.core.Dimensions;

public class PNGFileUtilsTest {

	@Test
	public void getDimensions_validPNGFile() throws Exception {
		Assertions.assertThat(PNGFileUtils.getDimensions(new File("src/test/resources/utils/png512x512.png")))
				.isEqualTo(new Dimensions(512));
	}

	@Test
	public void getDimensions_invalidFile() throws Exception {
		Assertions.assertThat(PNGFileUtils.getDimensions(new File("src/test/resources/utils/jpg500x500.jpg"))).isNull();
	}

}


text:
require 'spec_helper'

describe Ironfan::Dsl::Cluster do
  let(:cluster) do
    Ironfan.cluster 'sparky' do

      cloud(:ec2) do
        security_group(:ssh).authorize_port_range(22..22)
        flavor 't1.micro'
      end

      facet :web do
        instances 3
        cloud(:ec2) do
          flavor 'm1.small'
          mount_ephemerals(disks: { 0 => { mount_point: '/data' } })
        end
      end
    end

    Ironfan.cluster('sparky').resolve
  end

  context 'web facet server resolution' do
    subject(:facet){ cluster.facets.values.first }

    its(:name){ should eq('web') }

    it 'has the right number of servers' do
      facet.servers.length.should eq(3)
    end

    it 'has one cloud provider, EC2' do
      facet.servers[0].clouds.keys.should eq([:ec2])
    end

    it 'has its first ephemeral disk mounted at /data' do
      facet.servers[0].implied_volumes[1].mount_point.should eq('/data')
    end
  end

end


text:
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="CoreNLP-to-HTML.xsl" type="text/xsl"?>
<root>
  <document>
    <sentences>
      <sentence id="1">
        <tokens>
          <token id="1">
            <word>Been</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>0</CharacterOffsetBegin>
            <CharacterOffsetEnd>4</CharacterOffsetEnd>
            <POS>VBN</POS>
          </token>
          <token id="2">
            <word>wondering</word>
            <lemma>wonder</lemma>
            <CharacterOffsetBegin>5</CharacterOffsetBegin>
            <CharacterOffsetEnd>14</CharacterOffsetEnd>
            <POS>VBG</POS>
          </token>
          <token id="3">
            <word>this</word>
            <lemma>this</lemma>
            <CharacterOffsetBegin>15</CharacterOffsetBegin>
            <CharacterOffsetEnd>19</CharacterOffsetEnd>
            <POS>DT</POS>
          </token>
          <token id="4">
            <word>for</word>
            <lemma>for</lemma>
            <CharacterOffsetBegin>20</CharacterOffsetBegin>
            <CharacterOffsetEnd>23</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="5">
            <word>a</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>24</CharacterOffsetBegin>
            <CharacterOffsetEnd>25</CharacterOffsetEnd>
            <POS>DT</POS>
          </token>
          <token id="6">
            <word>while</word>
            <lemma>while</lemma>
            <CharacterOffsetBegin>26</CharacterOffsetBegin>
            <CharacterOffsetEnd>31</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="7">
            <word>.</word>
            <lemma>.</lemma>
            <CharacterOffsetBegin>31</CharacterOffsetBegin>
            <CharacterOffsetEnd>32</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (S (VP (VBN Been) (VP (VBG wondering) (NP (NP (DT this)) (PP (IN for) (NP (DT a) (NN while)))))) (. .))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="2">wondering</dependent>
          </dep>
          <dep type="aux">
            <governor idx="2">wondering</governor>
            <dependent idx="1">Been</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="2">wondering</governor>
            <dependent idx="3">this</dependent>
          </dep>
          <dep type="prep">
            <governor idx="3">this</governor>
            <dependent idx="4">for</dependent>
          </dep>
          <dep type="det">
            <governor idx="6">while</governor>
            <dependent idx="5">a</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="4">for</governor>
            <dependent idx="6">while</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="2">wondering</dependent>
          </dep>
          <dep type="aux">
            <governor idx="2">wondering</governor>
            <dependent idx="1">Been</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="2">wondering</governor>
            <dependent idx="3">this</dependent>
          </dep>
          <dep type="det">
            <governor idx="6">while</governor>
            <dependent idx="5">a</dependent>
          </dep>
          <dep type="prep_for">
            <governor idx="3">this</governor>
            <dependent idx="6">while</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="2">wondering</dependent>
          </dep>
          <dep type="aux">
            <governor idx="2">wondering</governor>
            <dependent idx="1">Been</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="2">wondering</governor>
            <dependent idx="3">this</dependent>
          </dep>
          <dep type="det">
            <governor idx="6">while</governor>
            <dependent idx="5">a</dependent>
          </dep>
          <dep type="prep_for">
            <governor idx="3">this</governor>
            <dependent idx="6">while</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="2">
        <tokens>
          <token id="1">
            <word>Do</word>
            <lemma>do</lemma>
            <CharacterOffsetBegin>33</CharacterOffsetBegin>
            <CharacterOffsetEnd>35</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="2">
            <word>they</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>36</CharacterOffsetBegin>
            <CharacterOffsetEnd>40</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="3">
            <word>still</word>
            <lemma>still</lemma>
            <CharacterOffsetBegin>41</CharacterOffsetBegin>
            <CharacterOffsetEnd>46</CharacterOffsetEnd>
            <POS>RB</POS>
          </token>
          <token id="4">
            <word>exist</word>
            <lemma>exist</lemma>
            <CharacterOffsetBegin>47</CharacterOffsetBegin>
            <CharacterOffsetEnd>52</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="5">
            <word>somewhere</word>
            <lemma>somewhere</lemma>
            <CharacterOffsetBegin>53</CharacterOffsetBegin>
            <CharacterOffsetEnd>62</CharacterOffsetEnd>
            <POS>RB</POS>
          </token>
          <token id="6">
            <word>?</word>
            <lemma>?</lemma>
            <CharacterOffsetBegin>62</CharacterOffsetBegin>
            <CharacterOffsetEnd>63</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (S (VP (VBP Do) (SBAR (S (NP (PRP they)) (ADVP (RB still)) (VP (VBP exist) (ADVP (RB somewhere)))))) (. ?))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="4">exist</governor>
            <dependent idx="2">they</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="3">still</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="1">Do</governor>
            <dependent idx="4">exist</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="5">somewhere</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="4">exist</governor>
            <dependent idx="2">they</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="3">still</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="1">Do</governor>
            <dependent idx="4">exist</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="5">somewhere</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="4">exist</governor>
            <dependent idx="2">they</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="3">still</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="1">Do</governor>
            <dependent idx="4">exist</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">exist</governor>
            <dependent idx="5">somewhere</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="3">
        <tokens>
          <token id="1">
            <word>When</word>
            <lemma>when</lemma>
            <CharacterOffsetBegin>64</CharacterOffsetBegin>
            <CharacterOffsetEnd>68</CharacterOffsetEnd>
            <POS>WRB</POS>
          </token>
          <token id="2">
            <word>you</word>
            <lemma>you</lemma>
            <CharacterOffsetBegin>69</CharacterOffsetBegin>
            <CharacterOffsetEnd>72</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="3">
            <word>delete</word>
            <lemma>delete</lemma>
            <CharacterOffsetBegin>73</CharacterOffsetBegin>
            <CharacterOffsetEnd>79</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="4">
            <word>them</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>80</CharacterOffsetBegin>
            <CharacterOffsetEnd>84</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="5">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>84</CharacterOffsetBegin>
            <CharacterOffsetEnd>85</CharacterOffsetEnd>
            <POS>,</POS>
          </token>
          <token id="6">
            <word>where</word>
            <lemma>where</lemma>
            <CharacterOffsetBegin>86</CharacterOffsetBegin>
            <CharacterOffsetEnd>91</CharacterOffsetEnd>
            <POS>WRB</POS>
          </token>
          <token id="7">
            <word>do</word>
            <lemma>do</lemma>
            <CharacterOffsetBegin>92</CharacterOffsetBegin>
            <CharacterOffsetEnd>94</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="8">
            <word>they</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>95</CharacterOffsetBegin>
            <CharacterOffsetEnd>99</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="9">
            <word>go</word>
            <lemma>go</lemma>
            <CharacterOffsetBegin>100</CharacterOffsetBegin>
            <CharacterOffsetEnd>102</CharacterOffsetEnd>
            <POS>VB</POS>
          </token>
          <token id="10">
            <word>?</word>
            <lemma>?</lemma>
            <CharacterOffsetBegin>102</CharacterOffsetBegin>
            <CharacterOffsetEnd>103</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (SBARQ (SBAR (WHADVP (WRB When)) (S (NP (PRP you)) (VP (VBP delete) (NP (PRP them))))) (, ,) (WHADVP (WRB where)) (SQ (VBP do) (NP (PRP they)) (VP (VB go))) (. ?))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="9">go</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">delete</governor>
            <dependent idx="1">When</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">delete</governor>
            <dependent idx="2">you</dependent>
          </dep>
          <dep type="dep">
            <governor idx="9">go</governor>
            <dependent idx="3">delete</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="3">delete</governor>
            <dependent idx="4">them</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="9">go</governor>
            <dependent idx="6">where</dependent>
          </dep>
          <dep type="aux">
            <governor idx="9">go</governor>
            <dependent idx="7">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="9">go</governor>
            <dependent idx="8">they</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="9">go</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">delete</governor>
            <dependent idx="1">When</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">delete</governor>
            <dependent idx="2">you</dependent>
          </dep>
          <dep type="dep">
            <governor idx="9">go</governor>
            <dependent idx="3">delete</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="3">delete</governor>
            <dependent idx="4">them</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="9">go</governor>
            <dependent idx="6">where</dependent>
          </dep>
          <dep type="aux">
            <governor idx="9">go</governor>
            <dependent idx="7">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="9">go</governor>
            <dependent idx="8">they</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="9">go</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="3">delete</governor>
            <dependent idx="1">When</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="3">delete</governor>
            <dependent idx="2">you</dependent>
          </dep>
          <dep type="dep">
            <governor idx="9">go</governor>
            <dependent idx="3">delete</dependent>
          </dep>
          <dep type="dobj">
            <governor idx="3">delete</governor>
            <dependent idx="4">them</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="9">go</governor>
            <dependent idx="6">where</dependent>
          </dep>
          <dep type="aux">
            <governor idx="9">go</governor>
            <dependent idx="7">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="9">go</governor>
            <dependent idx="8">they</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="4">
        <tokens>
          <token id="1">
            <word>They</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>104</CharacterOffsetBegin>
            <CharacterOffsetEnd>108</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="2">
            <word>do</word>
            <lemma>do</lemma>
            <CharacterOffsetBegin>109</CharacterOffsetBegin>
            <CharacterOffsetEnd>111</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="3">
            <word>n't</word>
            <lemma>not</lemma>
            <CharacterOffsetBegin>111</CharacterOffsetBegin>
            <CharacterOffsetEnd>114</CharacterOffsetEnd>
            <POS>RB</POS>
          </token>
          <token id="4">
            <word>get</word>
            <lemma>get</lemma>
            <CharacterOffsetBegin>115</CharacterOffsetBegin>
            <CharacterOffsetEnd>118</CharacterOffsetEnd>
            <POS>VB</POS>
          </token>
          <token id="5">
            <word>stored</word>
            <lemma>store</lemma>
            <CharacterOffsetBegin>119</CharacterOffsetBegin>
            <CharacterOffsetEnd>125</CharacterOffsetEnd>
            <POS>VBN</POS>
          </token>
          <token id="6">
            <word>in</word>
            <lemma>in</lemma>
            <CharacterOffsetBegin>126</CharacterOffsetBegin>
            <CharacterOffsetEnd>128</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="7">
            <word>your</word>
            <lemma>you</lemma>
            <CharacterOffsetBegin>129</CharacterOffsetBegin>
            <CharacterOffsetEnd>133</CharacterOffsetEnd>
            <POS>PRP$</POS>
          </token>
          <token id="8">
            <word>computer</word>
            <lemma>computer</lemma>
            <CharacterOffsetBegin>134</CharacterOffsetBegin>
            <CharacterOffsetEnd>142</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="9">
            <word>;</word>
            <lemma>;</lemma>
            <CharacterOffsetBegin>142</CharacterOffsetBegin>
            <CharacterOffsetEnd>143</CharacterOffsetEnd>
            <POS>:</POS>
          </token>
          <token id="10">
            <word>they</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>144</CharacterOffsetBegin>
            <CharacterOffsetEnd>148</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="11">
            <word>have</word>
            <lemma>have</lemma>
            <CharacterOffsetBegin>149</CharacterOffsetBegin>
            <CharacterOffsetEnd>153</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="12">
            <word>to</word>
            <lemma>to</lemma>
            <CharacterOffsetBegin>154</CharacterOffsetBegin>
            <CharacterOffsetEnd>156</CharacterOffsetEnd>
            <POS>TO</POS>
          </token>
          <token id="13">
            <word>go</word>
            <lemma>go</lemma>
            <CharacterOffsetBegin>157</CharacterOffsetBegin>
            <CharacterOffsetEnd>159</CharacterOffsetEnd>
            <POS>VB</POS>
          </token>
          <token id="14">
            <word>to</word>
            <lemma>to</lemma>
            <CharacterOffsetBegin>160</CharacterOffsetBegin>
            <CharacterOffsetEnd>162</CharacterOffsetEnd>
            <POS>TO</POS>
          </token>
          <token id="15">
            <word>some</word>
            <lemma>some</lemma>
            <CharacterOffsetBegin>163</CharacterOffsetBegin>
            <CharacterOffsetEnd>167</CharacterOffsetEnd>
            <POS>DT</POS>
          </token>
          <token id="16">
            <word>place</word>
            <lemma>place</lemma>
            <CharacterOffsetBegin>168</CharacterOffsetBegin>
            <CharacterOffsetEnd>173</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="17">
            <word>online</word>
            <lemma>online</lemma>
            <CharacterOffsetBegin>174</CharacterOffsetBegin>
            <CharacterOffsetEnd>180</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="18">
            <word>do</word>
            <lemma>do</lemma>
            <CharacterOffsetBegin>181</CharacterOffsetBegin>
            <CharacterOffsetEnd>183</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="19">
            <word>n't</word>
            <lemma>not</lemma>
            <CharacterOffsetBegin>183</CharacterOffsetBegin>
            <CharacterOffsetEnd>186</CharacterOffsetEnd>
            <POS>RB</POS>
          </token>
          <token id="20">
            <word>they</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>187</CharacterOffsetBegin>
            <CharacterOffsetEnd>191</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="21">
            <word>?</word>
            <lemma>?</lemma>
            <CharacterOffsetBegin>191</CharacterOffsetBegin>
            <CharacterOffsetEnd>192</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (SINV (S (S (NP (PRP They)) (VP (VBP do) (RB n't) (VP (VB get) (VP (VBN stored) (PP (IN in) (NP (PRP$ your) (NN computer))))))) (: ;) (S (NP (PRP they)) (VP (VBP have) (S (VP (TO to) (VP (VB go) (PP (TO to) (NP (DT some) (NN place))) (PP (NN online)))))))) (VP (VBP do) (RB n't)) (NP (PRP they)) (. ?))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">do</dependent>
          </dep>
          <dep type="nsubjpass">
            <governor idx="5">stored</governor>
            <dependent idx="1">They</dependent>
          </dep>
          <dep type="aux">
            <governor idx="5">stored</governor>
            <dependent idx="2">do</dependent>
          </dep>
          <dep type="neg">
            <governor idx="5">stored</governor>
            <dependent idx="3">n't</dependent>
          </dep>
          <dep type="auxpass">
            <governor idx="5">stored</governor>
            <dependent idx="4">get</dependent>
          </dep>
          <dep type="dep">
            <governor idx="18">do</governor>
            <dependent idx="5">stored</dependent>
          </dep>
          <dep type="prep">
            <governor idx="5">stored</governor>
            <dependent idx="6">in</dependent>
          </dep>
          <dep type="poss">
            <governor idx="8">computer</governor>
            <dependent idx="7">your</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="6">in</governor>
            <dependent idx="8">computer</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="11">have</governor>
            <dependent idx="10">they</dependent>
          </dep>
          <dep type="parataxis">
            <governor idx="5">stored</governor>
            <dependent idx="11">have</dependent>
          </dep>
          <dep type="aux">
            <governor idx="13">go</governor>
            <dependent idx="12">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="11">have</governor>
            <dependent idx="13">go</dependent>
          </dep>
          <dep type="prep">
            <governor idx="13">go</governor>
            <dependent idx="14">to</dependent>
          </dep>
          <dep type="det">
            <governor idx="16">place</governor>
            <dependent idx="15">some</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="14">to</governor>
            <dependent idx="16">place</dependent>
          </dep>
          <dep type="prep">
            <governor idx="13">go</governor>
            <dependent idx="17">online</dependent>
          </dep>
          <dep type="neg">
            <governor idx="18">do</governor>
            <dependent idx="19">n't</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">do</governor>
            <dependent idx="20">they</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">do</dependent>
          </dep>
          <dep type="nsubjpass">
            <governor idx="5">stored</governor>
            <dependent idx="1">They</dependent>
          </dep>
          <dep type="aux">
            <governor idx="5">stored</governor>
            <dependent idx="2">do</dependent>
          </dep>
          <dep type="neg">
            <governor idx="5">stored</governor>
            <dependent idx="3">n't</dependent>
          </dep>
          <dep type="auxpass">
            <governor idx="5">stored</governor>
            <dependent idx="4">get</dependent>
          </dep>
          <dep type="dep">
            <governor idx="18">do</governor>
            <dependent idx="5">stored</dependent>
          </dep>
          <dep type="poss">
            <governor idx="8">computer</governor>
            <dependent idx="7">your</dependent>
          </dep>
          <dep type="prep_in">
            <governor idx="5">stored</governor>
            <dependent idx="8">computer</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="11">have</governor>
            <dependent idx="10">they</dependent>
          </dep>
          <dep type="parataxis">
            <governor idx="5">stored</governor>
            <dependent idx="11">have</dependent>
          </dep>
          <dep type="aux">
            <governor idx="13">go</governor>
            <dependent idx="12">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="11">have</governor>
            <dependent idx="13">go</dependent>
          </dep>
          <dep type="det">
            <governor idx="16">place</governor>
            <dependent idx="15">some</dependent>
          </dep>
          <dep type="prep_to">
            <governor idx="13">go</governor>
            <dependent idx="16">place</dependent>
          </dep>
          <dep type="prep">
            <governor idx="13">go</governor>
            <dependent idx="17">online</dependent>
          </dep>
          <dep type="neg">
            <governor idx="18">do</governor>
            <dependent idx="19">n't</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">do</governor>
            <dependent idx="20">they</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="18">do</dependent>
          </dep>
          <dep type="nsubjpass">
            <governor idx="5">stored</governor>
            <dependent idx="1">They</dependent>
          </dep>
          <dep type="aux">
            <governor idx="5">stored</governor>
            <dependent idx="2">do</dependent>
          </dep>
          <dep type="neg">
            <governor idx="5">stored</governor>
            <dependent idx="3">n't</dependent>
          </dep>
          <dep type="auxpass">
            <governor idx="5">stored</governor>
            <dependent idx="4">get</dependent>
          </dep>
          <dep type="dep">
            <governor idx="18">do</governor>
            <dependent idx="5">stored</dependent>
          </dep>
          <dep type="poss">
            <governor idx="8">computer</governor>
            <dependent idx="7">your</dependent>
          </dep>
          <dep type="prep_in">
            <governor idx="5">stored</governor>
            <dependent idx="8">computer</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="11">have</governor>
            <dependent idx="10">they</dependent>
          </dep>
          <dep type="parataxis">
            <governor idx="5">stored</governor>
            <dependent idx="11">have</dependent>
          </dep>
          <dep type="aux">
            <governor idx="13">go</governor>
            <dependent idx="12">to</dependent>
          </dep>
          <dep type="xcomp">
            <governor idx="11">have</governor>
            <dependent idx="13">go</dependent>
          </dep>
          <dep type="det">
            <governor idx="16">place</governor>
            <dependent idx="15">some</dependent>
          </dep>
          <dep type="prep_to">
            <governor idx="13">go</governor>
            <dependent idx="16">place</dependent>
          </dep>
          <dep type="prep">
            <governor idx="13">go</governor>
            <dependent idx="17">online</dependent>
          </dep>
          <dep type="neg">
            <governor idx="18">do</governor>
            <dependent idx="19">n't</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="18">do</governor>
            <dependent idx="20">they</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="5">
        <tokens>
          <token id="1">
            <word>Thanks</word>
            <lemma>thanks</lemma>
            <CharacterOffsetBegin>193</CharacterOffsetBegin>
            <CharacterOffsetEnd>199</CharacterOffsetEnd>
            <POS>NNS</POS>
          </token>
          <token id="2">
            <word>;-RRB-</word>
            <lemma>;-rrb-</lemma>
            <CharacterOffsetBegin>200</CharacterOffsetBegin>
            <CharacterOffsetEnd>202</CharacterOffsetEnd>
            <POS>CD</POS>
          </token>
          <token id="3">
            <word>Where</word>
            <lemma>where</lemma>
            <CharacterOffsetBegin>203</CharacterOffsetBegin>
            <CharacterOffsetEnd>208</CharacterOffsetEnd>
            <POS>WRB</POS>
          </token>
          <token id="4">
            <word>do</word>
            <lemma>do</lemma>
            <CharacterOffsetBegin>209</CharacterOffsetBegin>
            <CharacterOffsetEnd>211</CharacterOffsetEnd>
            <POS>VBP</POS>
          </token>
          <token id="5">
            <word>they</word>
            <lemma>they</lemma>
            <CharacterOffsetBegin>212</CharacterOffsetBegin>
            <CharacterOffsetEnd>216</CharacterOffsetEnd>
            <POS>PRP</POS>
          </token>
          <token id="6">
            <word>go</word>
            <lemma>go</lemma>
            <CharacterOffsetBegin>217</CharacterOffsetBegin>
            <CharacterOffsetEnd>219</CharacterOffsetEnd>
            <POS>VB</POS>
          </token>
          <token id="7">
            <word>after</word>
            <lemma>after</lemma>
            <CharacterOffsetBegin>220</CharacterOffsetBegin>
            <CharacterOffsetEnd>225</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="8">
            <word>deletion</word>
            <lemma>deletion</lemma>
            <CharacterOffsetBegin>226</CharacterOffsetBegin>
            <CharacterOffsetEnd>234</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="9">
            <word>?</word>
            <lemma>?</lemma>
            <CharacterOffsetBegin>234</CharacterOffsetBegin>
            <CharacterOffsetEnd>235</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (FRAG (NP (NP (NNS Thanks) (CD ;-RRB-)) (SBAR (WHADVP (WRB Where)) (S (VP (VBP do) (S (NP (PRP they)) (VP (VB go) (PP (IN after) (NP (NN deletion))))))))) (. ?))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Thanks</dependent>
          </dep>
          <dep type="num">
            <governor idx="1">Thanks</governor>
            <dependent idx="2">;-RRB-</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">do</governor>
            <dependent idx="3">Where</dependent>
          </dep>
          <dep type="rcmod">
            <governor idx="1">Thanks</governor>
            <dependent idx="4">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">go</governor>
            <dependent idx="5">they</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="4">do</governor>
            <dependent idx="6">go</dependent>
          </dep>
          <dep type="prep">
            <governor idx="6">go</governor>
            <dependent idx="7">after</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="7">after</governor>
            <dependent idx="8">deletion</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Thanks</dependent>
          </dep>
          <dep type="num">
            <governor idx="1">Thanks</governor>
            <dependent idx="2">;-RRB-</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">do</governor>
            <dependent idx="3">Where</dependent>
          </dep>
          <dep type="rcmod">
            <governor idx="1">Thanks</governor>
            <dependent idx="4">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">go</governor>
            <dependent idx="5">they</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="4">do</governor>
            <dependent idx="6">go</dependent>
          </dep>
          <dep type="prep_after">
            <governor idx="6">go</governor>
            <dependent idx="8">deletion</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">Thanks</dependent>
          </dep>
          <dep type="num">
            <governor idx="1">Thanks</governor>
            <dependent idx="2">;-RRB-</dependent>
          </dep>
          <dep type="advmod">
            <governor idx="4">do</governor>
            <dependent idx="3">Where</dependent>
          </dep>
          <dep type="rcmod">
            <governor idx="1">Thanks</governor>
            <dependent idx="4">do</dependent>
          </dep>
          <dep type="nsubj">
            <governor idx="6">go</governor>
            <dependent idx="5">they</dependent>
          </dep>
          <dep type="ccomp">
            <governor idx="4">do</governor>
            <dependent idx="6">go</dependent>
          </dep>
          <dep type="prep_after">
            <governor idx="6">go</governor>
            <dependent idx="8">deletion</dependent>
          </dep>
        </dependencies>
      </sentence>
    </sentences>
  </document>
</root>


text:
<?php
declare (strict_types = 1);

namespace GrottoPress\Jentil\Setups\Styles;

use GrottoPress\Jentil\Utilities;
use GrottoPress\Jentil\Utilities\FileSystem;
use GrottoPress\Jentil\AbstractTheme;
use GrottoPress\Jentil\AbstractTestCase;
use Codeception\Util\Stub;
use tad\FunctionMocker\FunctionMocker;

class GutenbergTest extends AbstractTestCase
{
    public function testRun()
    {
        $add_action = FunctionMocker::replace('add_action');

        $style = new Posts(Stub::makeEmpty(AbstractTheme::class, [
            'meta' => ['slug' => 'jentil'],
        ]));

        $style->run();

        $add_action->wasCalledOnce();
        $add_action->wasCalledWithOnce([
            'wp_enqueue_scripts',
            [$style, 'enqueue']
        ]);
    }

    /**
     * @dataProvider enqueueProvider
     */
    public function testEnqueue(bool $rtl)
    {
        $enqueue = FunctionMocker::replace('wp_enqueue_style');

        FunctionMocker::replace('is_rtl', $rtl);

        $test_css = \codecept_data_dir('styles/test.css');

        $jentil = Stub::makeEmpty(AbstractTheme::class, [
            'utilities' => Stub::makeEmpty(Utilities::class),
            'meta' => ['slug' => 'jentil'],
        ]);

        $jentil->utilities->fileSystem = Stub::makeEmpty(FileSystem::class, [
            'dir' => function (
                string $type,
                string $append
            ) use ($test_css): string {
                return 'path' === $type ? $test_css : "http://my.url{$append}";
            }
        ]);

        $style = new Gutenberg($jentil);

        $style->enqueue();

        $enqueue->wasCalledOnce();
        $enqueue->wasCalledWithOnce([
            $style->id,
            (
                $rtl ?
                'http://my.url/dist/styles/gutenberg-rtl.min.css' :
                'http://my.url/dist/styles/gutenberg.min.css'
            ),
            [],
            \filemtime($test_css),
        ]);
    }

    public function enqueueProvider(): array
    {
        return [
            'is RTL' => [true],
            'is LTR' => [false],
        ];
    }
}


text:
<?xml version='1.0' encoding='utf-8'?>
<Jobs>
  <ApplicationJob xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Guid="f8232077-bb09-49a3-882e-c804a03064cf">
    <WebsiteUrl />
    <UserAgent />
    <UserNotes />
    <LastFileSize>16433152</LastFileSize>
    <LastFileDate>2015-11-02T12:46:28.8511521</LastFileDate>
    <IgnoreFileInformation>false</IgnoreFileInformation>
    <DownloadBeta>Default</DownloadBeta>
    <DownloadDate xsi:nil="true" />
    <CheckForUpdatesOnly>false</CheckForUpdatesOnly>
    <VariableChangeIndicator />
    <HashVariable />
    <HashType>None</HashType>
    <CanBeShared>true</CanBeShared>
    <ShareApplication>false</ShareApplication>
    <ExclusiveDownload>false</ExclusiveDownload>
    <HttpReferer />
    <SetupInstructions />
    <Variables>
      <item>
        <key>
          <string>nopush</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <TextualContent>--nopush</TextualContent>
            <Name>nopush</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>version</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <Url />
            <TextualContent>{getUrl:regex:(?<=TortoiseGit-)[\d.]{3,\}(?=-)}</TextualContent>
            <Name>version</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>url</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <Url />
            <TextualContent>https://{getUrl}</TextualContent>
            <Name>url</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>url64</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <TextualContent>https://{getUrl64}</TextualContent>
            <Name>url64</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>getUrl</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>RegularExpression</VariableType>
            <Regex>download\.[^ "'<>\*]+32bit.msi</Regex>
            <Url>https://tortoisegit.org/download/</Url>
            <Name>getUrl</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>getUrl64</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>RegularExpression</VariableType>
            <Regex>download\.[^ "'<>\*]+64bit.msi</Regex>
            <Url>https://tortoisegit.org/download/</Url>
            <Name>getUrl64</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>checksum64file</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <TextualContent>{url64}</TextualContent>
            <Name>checksum64file</Name>
          </UrlVariable>
        </value>
      </item>
      <item>
        <key>
          <string>cscript</string>
        </key>
        <value>
          <UrlVariable>
            <RegexRightToLeft>false</RegexRightToLeft>
            <VariableType>Textual</VariableType>
            <Regex />
            <TextualContent>2</TextualContent>
            <Name>cscript</Name>
          </UrlVariable>
        </value>
      </item>
    </Variables>
    <ExecuteCommand />
    <ExecutePreCommand />
    <ExecuteCommandType>Batch</ExecuteCommandType>
    <ExecutePreCommandType>Batch</ExecutePreCommandType>
    <Category />
    <SourceType>FixedUrl</SourceType>
    <PreviousLocation>F:\exe\TortoiseGit-1.8.16.0-32bit.msi</PreviousLocation>
    <DeletePreviousFile>false</DeletePreviousFile>
    <Enabled>true</Enabled>
    <FileHippoId />
    <LastUpdated>2015-11-02T12:46:28.8511521</LastUpdated>
    <TargetPath>{workdir}\</TargetPath>
    <FixedDownloadUrl>{url}</FixedDownloadUrl>
    <Name>tortoisegit</Name>
  </ApplicationJob>
</Jobs>


text:
import sys

class ArraySizeError(Exception):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)

if __name__ == '__main__':
    try:
        raise ArraySizeError("array size unequal")
    except Exception, e:
        print str(e)


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

package main

import (
	"context"
	"fmt"
	"io"

	"github.com/spf13/cobra"

	mixerpb "istio.io/api/mixer/api/v1"
)

func reportCmd(rootArgs *rootArgs, errorf errorFn) *cobra.Command {
	return &cobra.Command{
		Use:   "report <message>...",
		Short: "Invokes the mixer's Report API.",
		Run: func(cmd *cobra.Command, args []string) {
			report(rootArgs, args, errorf)
		}}
}

func report(rootArgs *rootArgs, args []string, errorf errorFn) {
	var attrs *mixerpb.Attributes
	var err error

	if attrs, err = parseAttributes(rootArgs); err != nil {
		errorf(err.Error())
		return
	}

	if len(args) == 0 {
		errorf("Message is missing.")
		return
	}

	var cs *clientState
	if cs, err = createAPIClient(rootArgs.mixerAddress); err != nil {
		errorf("Unable to establish connection to %s: %v", rootArgs.mixerAddress, err)
		return
	}
	defer deleteAPIClient(cs)

	var stream mixerpb.Mixer_ReportClient
	if stream, err = cs.client.Report(context.Background()); err != nil {
		errorf("Report RPC failed: %v", err)
		return
	}

	// send the request
	request := mixerpb.ReportRequest{RequestIndex: 0, AttributeUpdate: attrs}

	/* reinstate this code ASAP

	request.LogEntries = make([]*mixerpb.LogEntry, len(args))
	for i, arg := range args {
		now, _ := ptypes.TimestampProto(time.Now())
		request.LogEntries[i] = &mixerpb.LogEntry{
			Severity:  mixerpb.LogEntry_DEFAULT,
			Timestamp: now,
			Payload: &mixerpb.LogEntry_TextPayload{
				TextPayload: arg,
			},
		}
	}
	*/
	if err = stream.Send(&request); err != nil {
		errorf("Failed to send Report RPC: %v", err)
		return
	}

	var response *mixerpb.ReportResponse
	response, err = stream.Recv()
	if err == io.EOF {
		errorf("Got no response from Report RPC")
		return
	} else if err != nil {
		errorf("Failed to receive a response from Report RPC: %v", err)
		return
	}

	if err = stream.CloseSend(); err != nil {
		errorf("Failed to close gRPC stream: %v", err)
	}

	fmt.Printf("Report RPC returned %v\n", response.Result)
}


text:
#include <boost/phoenix/object/static_cast.hpp>
int main() {}


text:
Nextras\Dbal
============

[![Build Status](https://travis-ci.org/nextras/dbal.svg?branch=master)](https://travis-ci.org/nextras/dbal)
[![Downloads this Month](https://img.shields.io/packagist/dm/nextras/dbal.svg?style=flat)](https://packagist.org/packages/nextras/dbal)
[![Stable version](http://img.shields.io/packagist/v/nextras/dbal.svg?style=flat)](https://packagist.org/packages/nextras/dbal)
[![Code coverage](https://img.shields.io/coveralls/nextras/dbal.svg?style=flat)](https://coveralls.io/r/nextras/dbal)
[![HHVM Status](http://img.shields.io/hhvm/nextras/dbal.svg?style=flat)](http://hhvm.h4cc.de/package/nextras/dbal)

### Installation

Use composer:

```bash
$ composer require nextras/dbal
```

### Docs & sources

- [Documentation](http://nextras.cz/dbal/docs)

### Thanks

This project is inspired by great libraries:
- [Doctrine\DBAL](http://www.doctrine-project.org) - [GitHub](https://github.com/doctrine/dbal)
- [dibi](http://dibiphp.org) - [GitHub](https://github.com/dg/dibi)
- [Nette\Database](http://nette.org) - [GitHub](https://github.com/nette/database)

### License

MIT. See full [license](license.md).


text:
class Eligibility::Validation::FalseValidation < Eligibility::Validation::Base
  def valid?
    !eligibility.public_send("#{question}?")
  end
end


text:
class Light
{
	public:
		Light();
		Light(const int Radius, const sf::Color Color, const int PosX, const int PosY, bool IsBinded = 0, int UnitVecID = 0);
		int radius;
		sf::Color color;
		int posX, posY;

		bool isBindedToUnit;
		int unitVecID;
};

#endif // LIGHT_HPP


text:
package main

import (
	"bufio"
	"flag"
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"strings"
	"sync"
	"time"

	//"runtime/pprof"

	"github.com/golang/glog"
	"github.com/livepeer/go-livepeer/common"
	"github.com/livepeer/lpms/ffmpeg"
	"github.com/livepeer/m3u8"
	"github.com/olekukonko/tablewriter"
)

func main() {
	// Override the default flag set since there are dependencies that
	// incorrectly add their own flags (specifically, due to the 'testing'
	// package being linked)
	flag.Set("logtostderr", "true")
	flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)

	in := flag.String("in", "", "Input m3u8 manifest file")
	live := flag.Bool("live", true, "Simulate live stream")
	concurrentSessions := flag.Int("concurrentSessions", 1, "# of concurrent transcode sessions")
	repeat := flag.Int("repeat", 1, "# of times benchmark will be repeated")
	segs := flag.Int("segs", 0, "Maximum # of segments to transcode (default all)")
	log := flag.Int("log", 3, "Log level (1 fatal, 2 error, 3 warning, 4 info, 5 verbose, 6 debug, 7 trace, default warning)")
	transcodingOptions := flag.String("transcodingOptions", "P240p30fps16x9,P360p30fps16x9,P720p30fps16x9", "Transcoding options for broadcast job, or path to json config")
	nvidia := flag.String("nvidia", "", "Comma-separated list of Nvidia GPU device IDs (or \"all\" for all available devices)")
	netint := flag.String("netint", "", "Comma-separated list of NetInt device GUIDs (or \"all\" for all available devices)")
	outPrefix := flag.String("outPrefix", "", "Output segments' prefix (no segments are generated by default)")
	detectionFreq := flag.Int("detectionFreq", 0, "Run content-detection on every nth segment. No detection occurs for default frequency of 0.")
	detectionSampleRate := flag.Uint("detectionSampleRate", 1, "Run content-detection on every nth frame of a particular segment, if detectionFreq > 0.")
	concurrentSessionDelay := flag.Duration("concurrentSessionDelay", 300*time.Millisecond, "Delay before starting a new concurrent session")
	sign := flag.Bool("mpeg7Sign", false, "Calculate MPEG-7 video signature while transcoding")

	flag.Parse()

	if *in == "" {
		glog.Errorf("Please provide the input manifest as `%s -in <input.m3u8>`", os.Args[0])
		flag.Usage()
		os.Exit(1)
	}

	profiles := parseVideoProfiles(*transcodingOptions)

	f, err := os.Open(*in)
	if err != nil {
		glog.Fatal("Couldn't open input manifest: ", err)
	}
	p, _, err := m3u8.DecodeFrom(bufio.NewReader(f), true)
	if err != nil {
		glog.Fatal("Couldn't decode input manifest: ", err)
	}
	pl, ok := p.(*m3u8.MediaPlaylist)
	if !ok {
		glog.Fatalf("Expecting media playlist in the input %s", *in)
	}

	accel := ffmpeg.Software
	devices := []string{}
	if *nvidia != "" {
		var err error
		accel = ffmpeg.Nvidia
		devices, err = common.ParseAccelDevices(*nvidia, accel)
		if err != nil {
			glog.Fatalf("Error while parsing '-nvidia %v' flag: %v", *nvidia, err)
		}
	}

	if *netint != "" {
		var err error
		accel = ffmpeg.Netint
		devices, err = common.ParseAccelDevices(*netint, accel)
		if err != nil {
			glog.Fatalf("Error while parsing '-netint %v' flag: %v", *netint, err)
		}
	}

	glog.Infof("log level is: %d", ffmpeg.LogLevel(*log*8))
	ffmpeg.InitFFmpegWithLogLevel(ffmpeg.LogLevel(*log * 8))

	var wg sync.WaitGroup
	dir := path.Dir(*in)

	table := tablewriter.NewWriter(os.Stderr)
	data := [][]string{
		{"Source File", *in},
		{"Transcoding Options", *transcodingOptions},
		{"Concurrent Sessions", fmt.Sprintf("%v", *concurrentSessions)},
		{"Live Mode", fmt.Sprintf("%v", *live)},
		{"MPEG-7 Sign Mode", fmt.Sprintf("%v", *sign)},
	}

	if accel == ffmpeg.Nvidia && len(devices) > 0 {
		data = append(data, []string{"Nvidia GPU IDs", fmt.Sprintf("%v", strings.Join(devices, ","))})
	}

	if accel == ffmpeg.Netint && len(devices) > 0 {
		data = append(data, []string{"Netint GUIDs", fmt.Sprintf("%v", strings.Join(devices, ","))})
	}

	fmt.Printf("data %s \n", data)

	if *detectionFreq > 0 {
		data = append(data, []string{"Content Detection (segment_freq,frame_sample_rate)", fmt.Sprintf("%v,%v", *detectionFreq, *detectionSampleRate)})
	}
	if *repeat > 1 {
		data = append(data, []string{"Repeat Times", fmt.Sprintf("%v", *repeat)})
	}

	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetCenterSeparator("*")
	table.SetColumnSeparator("|")
	table.AppendBulk(data)
	table.Render()

	detectionOpts := ffmpeg.TranscodeOptions{
		Accel:        accel,
		AudioEncoder: ffmpeg.ComponentOptions{Name: "copy"},
		Detector: &ffmpeg.SceneClassificationProfile{
			SampleRate: *detectionSampleRate,
			Input:      ffmpeg.DSceneAdultSoccer.Input,
			Output:     ffmpeg.DSceneAdultSoccer.Output,
			Classes:    ffmpeg.DSceneAdultSoccer.Classes,
			ModelPath:  ffmpeg.DSceneAdultSoccer.ModelPath,
		},
	}

	ffmpeg.InitFFmpegWithLogLevel(ffmpeg.FFLogWarning)
	var detectorTc *ffmpeg.Transcoder
	if *detectionFreq > 0 {
		for _, d := range devices {
			t := time.Now()
			// We don't actually use this transcoder session, but initialize it to save time for model loading
			detectorTc, err = ffmpeg.NewTranscoderWithDetector(detectionOpts.Detector, d)
			end := time.Now()
			if err != nil {
				glog.Fatalf("Could not initialize detector profiles")
			}
			fmt.Printf("InitDetectorSession time %0.4v\n", end.Sub(t).Seconds())
			defer detectorTc.StopTranscoder()
		}
		fmt.Println("timestamp,session,segment,seg_dur,transcode_time,detect_data")
	} else {
		fmt.Println("timestamp,session,segment,seg_dur,transcode_time,frames")
	}

	var mu sync.Mutex
	for repeatCounter := 0; repeatCounter < *repeat; repeatCounter++ {
		segCount := 0
		realTimeSegCount := 0
		srcDur := 0.0
		transcodeDur := 0.0
		for i := 0; i < *concurrentSessions; i++ {
			wg.Add(1)
			go func(k int, wg *sync.WaitGroup) {
				var tc *ffmpeg.Transcoder
				if *detectionFreq > 0 {
					t := time.Now()
					tc, err = ffmpeg.NewTranscoderWithDetector(detectionOpts.Detector, devices[k%len(devices)])
					end := time.Now()
					fmt.Printf("InitDetectorSession time %0.4v for session %v\n", end.Sub(t).Seconds(), i)
					if err != nil {
						glog.Fatalf("Could not initialize detector")
					}
				} else {
					tc = ffmpeg.NewTranscoder()
				}
				for j, v := range pl.Segments {
					iterStart := time.Now()
					if *segs > 0 && j >= *segs {
						break
					}
					if v == nil {
						continue
					}
					u := path.Join(dir, v.URI)
					in := &ffmpeg.TranscodeOptionsIn{
						Fname: u,
						Accel: accel,
					}
					if ffmpeg.Software != accel {
						in.Device = devices[k%len(devices)]
						fmt.Printf("in.Device %s \n", in.Device)
					}
					profs2opts := func(profs []ffmpeg.VideoProfile) []ffmpeg.TranscodeOptions {
						opts := []ffmpeg.TranscodeOptions{}
						for n, p := range profs {
							oname := ""
							muxer := ""
							if *outPrefix != "" {
								oname = fmt.Sprintf("%s_%s_%d_%d_%d.ts", *outPrefix, p.Name, n, k, j)
								muxer = "mpegts"
							} else {
								oname = "-"
								muxer = "null"
							}
							o := ffmpeg.TranscodeOptions{
								Oname:        oname,
								Profile:      p,
								Accel:        accel,
								AudioEncoder: ffmpeg.ComponentOptions{Name: "copy"},
								Muxer:        ffmpeg.ComponentOptions{Name: muxer},
								CalcSign:     *sign,
							}
							opts = append(opts, o)
						}
						// add detector profile if freq > 0
						if *detectionFreq > 0 && j%*detectionFreq == 0 {
							opts = append(opts, detectionOpts)
						}
						return opts
					}
					out := profs2opts(profiles)
					t := time.Now()
					res, err := tc.Transcode(in, out)
					end := time.Now()
					if err != nil {
						glog.Fatalf("Transcoding failed for session %d segment %d: %v", k, j, err)
					}
					if *detectionFreq > 0 && j%*detectionFreq == 0 {
						fmt.Printf("%s,%d,%d,%0.4v,%0.4v,%v\n", end.Format("2006-01-02 15:04:05.9999"), k, j, v.Duration, end.Sub(t).Seconds(), res.Encoded[len(res.Encoded)-1].DetectData)
					} else {
						fmt.Printf("%s,%d,%d,%0.4v,%0.4v,%v\n", end.Format("2006-01-02 15:04:05.9999"), k, j, v.Duration, end.Sub(t).Seconds(), res.Encoded[0].Frames)
					}
					segTxDur := end.Sub(t).Seconds()
					mu.Lock()
					transcodeDur += segTxDur
					srcDur += v.Duration
					segCount++
					if segTxDur <= v.Duration {
						realTimeSegCount += 1
					}
					mu.Unlock()
					iterEnd := time.Now()
					segDur := time.Duration(v.Duration * float64(time.Second))
					if *live {
						time.Sleep(segDur - iterEnd.Sub(iterStart))
					}
				}
				tc.StopTranscoder()
				wg.Done()
			}(i, &wg)
			time.Sleep(*concurrentSessionDelay) // wait for at least one segment before moving on to the next session
		}
		wg.Wait()
		if segCount == 0 || srcDur == 0.0 {
			glog.Fatal("Input manifest has no segments or total duration is 0s")
		}
		statsTable := tablewriter.NewWriter(os.Stderr)
		stats := [][]string{
			{"Concurrent Sessions", fmt.Sprintf("%v", *concurrentSessions)},
			{"Total Segs Transcoded", fmt.Sprintf("%v", segCount)},
			{"Real-Time Segs Transcoded", fmt.Sprintf("%v", realTimeSegCount)},
			{"* Real-Time Segs Ratio *", fmt.Sprintf("%0.4v", float64(realTimeSegCount)/float64(segCount))},
			{"Total Source Duration", fmt.Sprintf("%vs", srcDur)},
			{"Total Transcoding Duration", fmt.Sprintf("%vs", transcodeDur)},
			{"* Real-Time Duration Ratio *", fmt.Sprintf("%0.4v", transcodeDur/srcDur)},
		}

		statsTable.SetAlignment(tablewriter.ALIGN_LEFT)
		statsTable.SetCenterSeparator("*")
		statsTable.SetColumnSeparator("|")
		statsTable.AppendBulk(stats)
		statsTable.Render()
	}
}

func parseVideoProfiles(inp string) []ffmpeg.VideoProfile {
	profiles := []ffmpeg.VideoProfile{}
	if inp != "" {
		// try opening up json file with profiles
		content, err := ioutil.ReadFile(inp)
		if err == nil && len(content) > 0 {
			// parse json profiles
			var parsingError error
			profiles, parsingError = ffmpeg.ParseProfiles(content)
			if parsingError != nil {
				glog.Fatal(parsingError)
			}
		} else {
			// check the built-in profiles
			profiles = make([]ffmpeg.VideoProfile, 0)
			presets := strings.Split(inp, ",")
			for _, v := range presets {
				if p, ok := ffmpeg.VideoProfileLookup[strings.TrimSpace(v)]; ok {
					profiles = append(profiles, p)
				}
			}
		}
		if len(profiles) <= 0 {
			glog.Fatalf("No transcoding options provided")
		}
	}
	return profiles
}


text:
<?php

namespace EmailMarketing\Application\Action\Tag;

use EmailMarketing\Application\Form\TagForm;
use EmailMarketing\Domain\Persistence\TagRepositoryInterface;
use EmailMarketing\Domain\Service\FlashMessageInterface;
use EmailMarketing\Domain\Service\TagServiceInterface;
use Exception;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Zend\Diactoros\Response\HtmlResponse;
use Zend\Diactoros\Response\RedirectResponse;
use Zend\Expressive\Router\RouterInterface;
use Zend\Expressive\Template;

class TagCreatePageAction
{

    private $template;

    private $repository;

    private $tagService;

    private $router;

    private $form;

    public function __construct(
        TagRepositoryInterface $repository,
        TagServiceInterface $tagService,
        Template\TemplateRendererInterface $template,
        RouterInterface $router,
        TagForm $form
    ) {
        $this->template = $template;
        $this->repository = $repository;
        $this->tagService = $tagService;
        $this->router = $router;
        $this->form = $form;
    }

    public function __invoke(
            ServerRequestInterface $request,
            ResponseInterface $response,
            callable $next = null
    ) {

        if ( $request->getMethod() == "POST" ){
            $flash = $request->getAttribute('flash');
            $dataForm = $request->getParsedBody();

            $this->form->setData($dataForm);

            if ( $this->form->isValid() ){
                $entity = $this->form->getData();

                try {
                    $this->tagService->create($entity);
                    $flash->setMessage(FlashMessageInterface::MESSAGE_SUCCESS, "Tag cadastrado com sucesso");
                    $uri = $this->router->generateUri('tag.list');
                    return new RedirectResponse( $uri );
                } catch (Exception $ex) {
                    $flash->setMessage(FlashMessageInterface::MESSAGE_ERROR, "Erro no cadastrado da tag");
                }
            }
        }

        return new HtmlResponse(
            $this->template->render('app::tag/create', [
                'form' => $this->form
            ])
        );
    }
}


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

package com.google.crypto.tink.apps.paymentmethodtoken;

import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.crypto.tink.HybridEncrypt;
import com.google.crypto.tink.apps.paymentmethodtoken.PaymentMethodTokenConstants.ProtocolVersionConfig;
import com.google.crypto.tink.subtle.Base64;
import com.google.crypto.tink.subtle.EciesHkdfSenderKem;
import com.google.gson.JsonObject;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.StringWriter;
import java.security.GeneralSecurityException;
import java.security.interfaces.ECPublicKey;
import java.util.Arrays;

/**
 * A {@link HybridEncrypt} implementation for the hybrid encryption used in <a
 * href="https://developers.google.com/pay/api/payment-data-cryptography">Google Payment Method
 * Token</a>.
 */
class PaymentMethodTokenHybridEncrypt implements HybridEncrypt {
  private final EciesHkdfSenderKem senderKem;
  private final ProtocolVersionConfig protocolVersionConfig;

  public PaymentMethodTokenHybridEncrypt(
      final ECPublicKey recipientPublicKey, final ProtocolVersionConfig protocolVersionConfig) {
    this.senderKem = new EciesHkdfSenderKem(recipientPublicKey);
    this.protocolVersionConfig = protocolVersionConfig;
  }

  static String jsonEncodeCiphertext(byte[] ciphertext, byte[] tag, byte[] ephemeralPublicKey)
      throws GeneralSecurityException {
    JsonObject result = new JsonObject();
    result.addProperty(
        PaymentMethodTokenConstants.JSON_ENCRYPTED_MESSAGE_KEY, Base64.encode(ciphertext));
    result.addProperty(
        PaymentMethodTokenConstants.JSON_EPHEMERAL_PUBLIC_KEY, Base64.encode(ephemeralPublicKey));
    result.addProperty(PaymentMethodTokenConstants.JSON_TAG_KEY, Base64.encode(tag));
    StringWriter stringWriter = new StringWriter();
    JsonWriter jsonWriter = new JsonWriter(stringWriter);
    jsonWriter.setHtmlSafe(true);
    try {
      Streams.write(result, jsonWriter);
      return stringWriter.toString();
    } catch (IOException e) {
      throw new GeneralSecurityException("cannot encrypt; JSON error", e);
    }
  }

  @Override
  public byte[] encrypt(final byte[] plaintext, final byte[] contextInfo)
      throws GeneralSecurityException {
    int symmetricKeySize =
        protocolVersionConfig.aesCtrKeySize + protocolVersionConfig.hmacSha256KeySize;
    EciesHkdfSenderKem.KemKey kemKey =
        senderKem.generateKey(
            PaymentMethodTokenConstants.HMAC_SHA256_ALGO,
            PaymentMethodTokenConstants.HKDF_EMPTY_SALT,
            contextInfo,
            symmetricKeySize,
            PaymentMethodTokenConstants.UNCOMPRESSED_POINT_FORMAT);
    byte[] aesCtrKey = Arrays.copyOf(kemKey.getSymmetricKey(), protocolVersionConfig.aesCtrKeySize);
    byte[] ciphertext = PaymentMethodTokenUtil.aesCtr(aesCtrKey, plaintext);
    byte[] hmacSha256Key =
        Arrays.copyOfRange(
            kemKey.getSymmetricKey(), protocolVersionConfig.aesCtrKeySize, symmetricKeySize);
    byte[] tag = PaymentMethodTokenUtil.hmacSha256(hmacSha256Key, ciphertext);
    byte[] ephemeralPublicKey = kemKey.getKemBytes();

    String jsonEncodedCiphertext = jsonEncodeCiphertext(ciphertext, tag, ephemeralPublicKey);
    return jsonEncodedCiphertext.getBytes(UTF_8);
  }
}