text:
package org.gradle.api.plugins;

import com.beust.jcommander.internal.Lists;
import org.gradle.api.*;
import org.gradle.api.artifacts.Configuration;
import org.gradle.api.artifacts.ConfigurationContainer;
import org.gradle.api.file.SourceDirectorySet;
import org.gradle.api.internal.ConventionMapping;
import org.gradle.api.internal.IConventionAware;
import org.gradle.api.internal.java.DefaultJavaSourceSet;
import org.gradle.api.internal.java.DefaultJvmResourceSet;
import org.gradle.api.internal.jvm.ClassDirectoryBinarySpecInternal;
import org.gradle.api.internal.jvm.DefaultClassDirectoryBinarySpec;
import org.gradle.api.internal.plugins.DslObject;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.api.internal.project.taskfactory.ITaskFactory;
import org.gradle.api.internal.tasks.SourceSetCompileClasspath;
import org.gradle.api.internal.tasks.testing.NoMatchingTestsReporter;
import org.gradle.api.reporting.ReportingExtension;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.compile.AbstractCompile;
import org.gradle.api.tasks.compile.JavaCompile;
import org.gradle.api.tasks.javadoc.Javadoc;
import org.gradle.api.tasks.testing.Test;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.jvm.Classpath;
import org.gradle.jvm.platform.internal.DefaultJavaPlatform;
import org.gradle.jvm.toolchain.JavaToolChain;
import org.gradle.language.base.ProjectSourceSet;
import org.gradle.language.base.plugins.LanguageBasePlugin;
import org.gradle.language.base.plugins.LifecycleBasePlugin;
import org.gradle.language.jvm.JvmResourceSet;
import org.gradle.language.jvm.tasks.ProcessResources;
import org.gradle.model.Mutate;
import org.gradle.model.RuleSource;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.ModelRegistrations;
import org.gradle.model.internal.registry.ModelRegistry;
import org.gradle.platform.base.BinaryContainer;
import org.gradle.platform.base.internal.BinarySpecInternal;
import org.gradle.platform.base.internal.DefaultComponentSpecIdentifier;
import org.gradle.platform.base.plugins.BinaryBasePlugin;
import org.gradle.util.WrapUtil;

import javax.inject.Inject;
import java.io.File;
import java.util.List;
import java.util.concurrent.Callable;

/**
 *
A {@link org.gradle.api.Plugin} which compiles and tests Java source, and assembles it into a JAR file.

 */
public class JavaBasePlugin implements Plugin<ProjectInternal> {
    public static final String CHECK_TASK_NAME = LifecycleBasePlugin.CHECK_TASK_NAME;

    public static final String VERIFICATION_GROUP = LifecycleBasePlugin.VERIFICATION_GROUP;
    public static final String BUILD_TASK_NAME = LifecycleBasePlugin.BUILD_TASK_NAME;
    public static final String BUILD_DEPENDENTS_TASK_NAME = "buildDependents";
    public static final String BUILD_NEEDED_TASK_NAME = "buildNeeded";
    public static final String DOCUMENTATION_GROUP = "documentation";

    private final Instantiator instantiator;
    private final JavaToolChain javaToolChain;
    private final ITaskFactory taskFactory;
    private final ModelRegistry modelRegistry;

    @Inject
    public JavaBasePlugin(Instantiator instantiator, JavaToolChain javaToolChain, ITaskFactory taskFactory, ModelRegistry modelRegistry) {
        this.instantiator = instantiator;
        this.javaToolChain = javaToolChain;
        this.taskFactory = taskFactory;
        this.modelRegistry = modelRegistry;
    }

    public void apply(ProjectInternal project) {
        project.getPluginManager().apply(BasePlugin.class);
        project.getPluginManager().apply(ReportingBasePlugin.class);
        project.getPluginManager().apply(LanguageBasePlugin.class);
        project.getPluginManager().apply(BinaryBasePlugin.class);

        JavaPluginConvention javaConvention = new JavaPluginConvention(project, instantiator);
        project.getConvention().getPlugins().put("java", javaConvention);

        configureCompileDefaults(project, javaConvention);
        BridgedBinaries binaries = configureSourceSetDefaults(javaConvention);

        modelRegistry.register(ModelRegistrations.bridgedInstance(ModelReference.of("bridgedBinaries", BridgedBinaries.class), binaries)
            .descriptor("JavaBasePlugin.apply()")
            .hidden(true)
            .build());

        configureJavaDoc(project, javaConvention);
        configureTest(project, javaConvention);
        configureBuildNeeded(project);
        configureBuildDependents(project);
    }

    private BridgedBinaries configureSourceSetDefaults(final JavaPluginConvention pluginConvention) {
        final Project project = pluginConvention.getProject();
        final List<ClassDirectoryBinarySpecInternal> binaries = Lists.newArrayList();
        pluginConvention.getSourceSets().all(new Action<SourceSet>() {
            public void execute(final SourceSet sourceSet) {
                ConventionMapping outputConventionMapping = ((IConventionAware) sourceSet.getOutput()).getConventionMapping();

                ConfigurationContainer configurations = project.getConfigurations();

                defineConfigurationsForSourceSet(sourceSet, configurations);
                definePathsForSourceSet(sourceSet, outputConventionMapping, project);

                createProcessResourcesTaskForBinary(sourceSet, sourceSet.getResources(), project);
                createCompileJavaTaskForBinary(sourceSet, sourceSet.getJava(), project);
                createBinaryLifecycleTask(sourceSet, project);

                DefaultComponentSpecIdentifier binaryId = new DefaultComponentSpecIdentifier(project.getPath(), sourceSet.getName());
                ClassDirectoryBinarySpecInternal binary = instantiator.newInstance(DefaultClassDirectoryBinarySpec.class, binaryId, sourceSet, javaToolChain, DefaultJavaPlatform.current(), instantiator, taskFactory);

                Classpath compileClasspath = new SourceSetCompileClasspath(sourceSet);
                DefaultJavaSourceSet javaSourceSet = instantiator.newInstance(DefaultJavaSourceSet.class, binaryId.child("java"), sourceSet.getJava(), compileClasspath);
                JvmResourceSet resourceSet = instantiator.newInstance(DefaultJvmResourceSet.class, binaryId.child("resources"), sourceSet.getResources());

                binary.addSourceSet(javaSourceSet);
                binary.addSourceSet(resourceSet);

                attachTasksToBinary(binary, sourceSet, project);
                binaries.add(binary);
            }
        });
        return new BridgedBinaries(binaries);
    }

    private void createCompileJavaTaskForBinary(final SourceSet sourceSet, SourceDirectorySet javaSourceSet, Project target) {
        JavaCompile compileTask = target.getTasks().create(sourceSet.getCompileJavaTaskName(), JavaCompile.class);
        compileTask.setDescription(String.format("Compiles %s.", javaSourceSet));
        compileTask.setSource(javaSourceSet);
        ConventionMapping conventionMapping = compileTask.getConventionMapping();
        conventionMapping.map("classpath", new Callable<Object>() {
            public Object call() throws Exception {
                return sourceSet.getCompileClasspath();
            }
        });
        conventionMapping.map("destinationDir", new Callable<Object>() {
            public Object call() throws Exception {
                return sourceSet.getOutput().getClassesDir();
            }
        });
    }

    private void createProcessResourcesTaskForBinary(final SourceSet sourceSet, SourceDirectorySet resourceSet, final Project target) {
        Copy resourcesTask = target.getTasks().create(sourceSet.getProcessResourcesTaskName(), ProcessResources.class);
        resourcesTask.setDescription(String.format("Processes %s.", resourceSet));
        new DslObject(resourcesTask).getConventionMapping().map("destinationDir", new Callable<File>() {
            public File call() throws Exception {
                return sourceSet.getOutput().getResourcesDir();
            }
        });
        resourcesTask.from(resourceSet);
    }

    private void createBinaryLifecycleTask(SourceSet sourceSet, Project target) {
        sourceSet.compiledBy(sourceSet.getClassesTaskName());

        Task binaryLifecycleTask = target.task(sourceSet.getClassesTaskName());
        binaryLifecycleTask.setGroup(LifecycleBasePlugin.BUILD_GROUP);
        binaryLifecycleTask.setDescription(String.format("Assembles %s.", sourceSet.getOutput()));
        binaryLifecycleTask.dependsOn(sourceSet.getOutput().getDirs());
        binaryLifecycleTask.dependsOn(sourceSet.getCompileJavaTaskName());
        binaryLifecycleTask.dependsOn(sourceSet.getProcessResourcesTaskName());
    }

    private void attachTasksToBinary(ClassDirectoryBinarySpecInternal binary, SourceSet sourceSet, Project target) {
        Task compileTask = target.getTasks().getByPath(sourceSet.getCompileJavaTaskName());
        Task resourcesTask = target.getTasks().getByPath(sourceSet.getProcessResourcesTaskName());
        Task classesTask = target.getTasks().getByPath(sourceSet.getClassesTaskName());
        binary.getTasks().add(compileTask);
        binary.getTasks().add(resourcesTask);
        binary.getTasks().add(classesTask);
        binary.setBuildTask(classesTask);
    }

    private void definePathsForSourceSet(final SourceSet sourceSet, ConventionMapping outputConventionMapping, final Project project) {
        outputConventionMapping.map("classesDir", new Callable<Object>() {
            public Object call() throws Exception {
                String classesDirName = String.format("classes/%s", sourceSet.getName());
                return new File(project.getBuildDir(), classesDirName);
            }
        });
        outputConventionMapping.map("resourcesDir", new Callable<Object>() {
            public Object call() throws Exception {
                String classesDirName = String.format("resources/%s", sourceSet.getName());
                return new File(project.getBuildDir(), classesDirName);
            }
        });

        sourceSet.getJava().srcDir(String.format("src/%s/java", sourceSet.getName()));
        sourceSet.getResources().srcDir(String.format("src/%s/resources", sourceSet.getName()));
    }

    private void defineConfigurationsForSourceSet(SourceSet sourceSet, ConfigurationContainer configurations) {
        Configuration compileConfiguration = configurations.maybeCreate(sourceSet.getCompileConfigurationName());
        compileConfiguration.setVisible(false);
        compileConfiguration.setDescription(String.format("Dependencies for %s.", sourceSet));

        Configuration runtimeConfiguration = configurations.maybeCreate(sourceSet.getRuntimeConfigurationName());
        runtimeConfiguration.setVisible(false);
        runtimeConfiguration.extendsFrom(compileConfiguration);
        runtimeConfiguration.setDescription(String.format("Runtime dependencies for %s.", sourceSet));

        Configuration compileOnlyConfiguration = configurations.maybeCreate(sourceSet.getCompileOnlyConfigurationName());
        compileOnlyConfiguration.setVisible(false);
        compileOnlyConfiguration.extendsFrom(compileConfiguration);
        compileOnlyConfiguration.setDescription(String.format("Compile dependencies for %s.", sourceSet));

        Configuration compileClasspathConfiguration = configurations.maybeCreate(sourceSet.getCompileClasspathConfigurationName());
        compileClasspathConfiguration.setVisible(false);
        compileClasspathConfiguration.extendsFrom(compileOnlyConfiguration);
        compileClasspathConfiguration.setDescription(String.format("Compile classpath for %s.", sourceSet));

        sourceSet.setCompileClasspath(compileClasspathConfiguration);
        sourceSet.setRuntimeClasspath(sourceSet.getOutput().plus(runtimeConfiguration));
    }

    public void configureForSourceSet(final SourceSet sourceSet, AbstractCompile compile) {
        ConventionMapping conventionMapping;
        compile.setDescription(String.format("Compiles the %s.", sourceSet.getJava()));
        conventionMapping = compile.getConventionMapping();
        compile.setSource(sourceSet.getJava());
        conventionMapping.map("classpath", new Callable<Object>() {
            public Object call() throws Exception {
                return sourceSet.getCompileClasspath();
            }
        });
        conventionMapping.map("destinationDir", new Callable<Object>() {
            public Object call() throws Exception {
                return sourceSet.getOutput().getClassesDir();
            }
        });
    }

    private void configureCompileDefaults(final Project project, final JavaPluginConvention javaConvention) {
        project.getTasks().withType(AbstractCompile.class, new Action<AbstractCompile>() {
            public void execute(final AbstractCompile compile) {
                ConventionMapping conventionMapping = compile.getConventionMapping();
                conventionMapping.map("sourceCompatibility", new Callable<Object>() {
                    public Object call() throws Exception {
                        return javaConvention.getSourceCompatibility().toString();
                    }
                });
                conventionMapping.map("targetCompatibility", new Callable<Object>() {
                    public Object call() throws Exception {
                        return javaConvention.getTargetCompatibility().toString();
                    }
                });
            }
        });
        project.getTasks().withType(JavaCompile.class, new Action<JavaCompile>() {
            public void execute(final JavaCompile compile) {
                ConventionMapping conventionMapping = compile.getConventionMapping();
                conventionMapping.map("dependencyCacheDir", new Callable<Object>() {
                    public Object call() throws Exception {
                        return javaConvention.getDependencyCacheDir();
                    }
                });
            }
        });
    }

    private void configureJavaDoc(final Project project, final JavaPluginConvention convention) {
        project.getTasks().withType(Javadoc.class, new Action<Javadoc>() {
            public void execute(Javadoc javadoc) {
                javadoc.getConventionMapping().map("destinationDir", new Callable<Object>() {
                    public Object call() throws Exception {
                        return new File(convention.getDocsDir(), "javadoc");
                    }
                });
                javadoc.getConventionMapping().map("title", new Callable<Object>() {
                    public Object call() throws Exception {
                        return project.getExtensions().getByType(ReportingExtension.class).getApiDocTitle();
                    }
                });
            }
        });
    }

    private void configureBuildNeeded(Project project) {
        DefaultTask buildTask = project.getTasks().create(BUILD_NEEDED_TASK_NAME, DefaultTask.class);
        buildTask.setDescription("Assembles and tests this project and all projects it depends on.");
        buildTask.setGroup(BasePlugin.BUILD_GROUP);
        buildTask.dependsOn(BUILD_TASK_NAME);
    }

    private void configureBuildDependents(Project project) {
        DefaultTask buildTask = project.getTasks().create(BUILD_DEPENDENTS_TASK_NAME, DefaultTask.class);
        buildTask.setDescription("Assembles and tests this project and all projects that depend on it.");
        buildTask.setGroup(BasePlugin.BUILD_GROUP);
        buildTask.dependsOn(BUILD_TASK_NAME);
    }

    private void configureTest(final Project project, final JavaPluginConvention convention) {
        project.getTasks().withType(Test.class, new Action<Test>() {
            public void execute(Test test) {
                configureTestDefaults(test, project, convention);
            }
        });
        project.afterEvaluate(new Action<Project>() {
            public void execute(Project project) {
                project.getTasks().withType(Test.class, new Action<Test>() {
                    public void execute(Test test) {
                        configureBasedOnSingleProperty(test);
                        overwriteDebugIfDebugPropertyIsSet(test);
                    }
                });
            }
        });
    }

    private void overwriteDebugIfDebugPropertyIsSet(Test test) {
        String debugProp = getTaskPrefixedProperty(test, "debug");
        if (debugProp != null) {
            test.prependParallelSafeAction(new Action<Task>() {
                public void execute(Task task) {
                    task.getLogger().info("Running tests for remote debugging.");
                }
            });
            test.setDebug(true);
        }
    }

    private void configureBasedOnSingleProperty(final Test test) {
        String singleTest = getTaskPrefixedProperty(test, "single");
        if (singleTest == null) {
            //configure inputs so that the test task is skipped when there are no source files.
            //unfortunately, this only applies when 'test.single' is *not* applied
            //We should fix this distinction, the behavior with 'test.single' or without it should be the same
            test.getInputs().source(test.getCandidateClassFiles());
            return;
        }
        test.prependParallelSafeAction(new Action<Task>() {
            public void execute(Task task) {
                test.getLogger().info("Running single tests with pattern: {}", test.getIncludes());
            }
        });
        test.setIncludes(WrapUtil.toSet(String.format("**/%s*.class", singleTest)));
        test.addTestListener(new NoMatchingTestsReporter("Could not find matching test for pattern: " + singleTest));
    }

    private String getTaskPrefixedProperty(Task task, String propertyName) {
        String suffix = '.' + propertyName;
        String value = System.getProperty(task.getPath() + suffix);
        if (value == null) {
            return System.getProperty(task.getName() + suffix);
        }
        return value;
    }

    private void configureTestDefaults(final Test test, Project project, final JavaPluginConvention convention) {
        DslObject htmlReport = new DslObject(test.getReports().getHtml());
        DslObject xmlReport = new DslObject(test.getReports().getJunitXml());

        xmlReport.getConventionMapping().map("destination", new Callable<Object>() {
            public Object call() throws Exception {
                return convention.getTestResultsDir();
            }
        });
        htmlReport.getConventionMapping().map("destination", new Callable<Object>() {
            public Object call() throws Exception {
                return convention.getTestReportDir();
            }
        });
        test.getConventionMapping().map("binResultsDir", new Callable<Object>() {
            public Object call() throws Exception {
                return new File(convention.getTestResultsDir(), String.format("binary/%s", test.getName()));
            }
        });
        test.workingDir(project.getProjectDir());
    }

    static class BridgedBinaries {
        final List<ClassDirectoryBinarySpecInternal> binaries;

        public BridgedBinaries(List<ClassDirectoryBinarySpecInternal> binaries) {
            this.binaries = binaries;
        }
    }

    static class Rules extends RuleSource {
        @Mutate
        void attachBridgedSourceSets(ProjectSourceSet projectSourceSet, BridgedBinaries bridgedBinaries) {
            for (ClassDirectoryBinarySpecInternal binary : bridgedBinaries.binaries) {
                projectSourceSet.addAll(binary.getInputs());
            }
        }

        @Mutate
        void attachBridgedBinaries(BinaryContainer binaries, BridgedBinaries bridgedBinaries) {
            for (BinarySpecInternal binary : bridgedBinaries.binaries) {
                binaries.put(binary.getProjectScopedName(), binary);
            }
        }
    }
}


text:
More details on the whats and whys on [StackMates](http://stackmates.dreamineering.com/stacks/mobile/drmg-start-ionic/)

With gulp, sass, browserify

Based on starting project using ionic start cli

# Getting Started ionic prerequisites

install ionic cli

- [Ionic CLI](https://github.com/driftyco/ionic-cli)

Cordova version 3.4.0-0.1.2 has a bug...

  npm install -g cordova@3.4.0-0.1.0

## Android

* ionic platform android
* ionic build android
* ionic emulate android (takes ages)
* ionic run android

re-run with

ionic run android

### Android tips

Use ADB chome plugin

## iOS

* ionic platform ios
* ionic build ios
* ionic emulate ios
* ionic run ios

### iOS tips

Scale down emulator

  window > scales | command 3

npm install -g cordova@3.4.0-0.1.0

## Best practices

* Use CSS animation
* Provide visual clues that stuff is happening (users expect instant response)
* Use your delusion

## Conversion

* Find yourproject and replace as appropriate

redpajama_set_name: RedPajamaGithub


text:
@implementation UIViewController (UAFAdditions_Navigation)

- (void)dismissViewController:(UIViewController *)viewController animated:(BOOL)flag completion:(void (^)(void))completion path:(NSIndexPath *)indexPath userInfo:(NSDictionary *)userInfo
{
  if (indexPath && [self conformsToProtocol:@protocol(UAFNavigationItem)]) {
    [(id)self viewWillAppearFromDismissalOfModalViewControllerOfClass:viewController.class withNavigationPath:indexPath andUserInfo:userInfo];
  }
  [self dismissViewControllerAnimated:flag completion:completion];
}

@end


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

<title>Progressive Rock Top Albums / all subgenres - all record types - 1973 - all countries</title>

<meta name="description" content="Progressive Rock Top Albums / all subgenres - all record types - 1973 - all countries / from Progarchives.com, the ultimate progressive rock website">

<meta name="keywords" content="Progressive Rock Top Albums / all subgenres - all record types - 1973 - all countries, progressive rock, prog rock, prog archives, prog archive, progarchive, free mp3, reviews, music, albums, forum, community, videos, auctions, cd, lp, dvd">
<link href="static-css/screen.css?v=29" rel="stylesheet"/>
<link href="https://fonts.googleapis.com/css?family=Open+Sans" rel="stylesheet"/>
<link media="only screen and (max-device-width: 480px)" href="static-css/mobile.css?v=27" rel="stylesheet"/>
<link href="/static-css/font-awesome_v463/css/font-awesome.min.css" rel="stylesheet"/>
<link href="/lib/starbox12/css/starbox.css" rel="stylesheet"/>
<link href="/lib/prototip2202/css/prototip.css" rel="stylesheet"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0">

<meta property="og:site_name" content="Progarchives.com"/>
<meta property="fb:admins" content="546882990"/>
<meta property="fb:app_id" content="131943541722	"/>
<meta name="verify-v1" content="gekxcnV9VQ1H7apKp4Geh+BYZ8obt1RE26pabGvprpE="/>
<meta name="google-site-verification" content="7zi8CAxLZW3Z8s4rVL0Bw-3YfQ60x_tENsOo0U7rdpM"/>
<meta name="robots" content="NOODP"/>

 HOME

 FORUMS

 PROG ROCK GUIDES

 LOG IN

 PROG RADIOS

 PROG LINKS

 FAQ

 ABOUT US

 PROG ROCK GUIDES

 LOG IN

 PROG RADIOS

 ROG LINKS

 FAQ

 ABOUT US

PROG SUB-GENRES:

Canterbury Scene

Crossover Prog

Eclectic Prog

Experimental/Post Metal

Heavy Prog

Indo-Prog/Raga Rock

Jazz Rock/Fusion

Krautrock

Neo-Prog

Post Rock/Math Rock

Prog Folk

Progressive Electronic

Progressive Metal

Psychedelic/Space Rock

RIO/Avant-Prog

Rock Progressivo Italiano

Symphonic Prog

Tech/Extreme Prog Metal

Zeuhl

Various Genres/Artists

Prog Related

Proto-Prog

POPULAR ARTISTS (TOP 50, LAST 24H) :

Marillion

Kansas

Opeth

Liquid Tension Experiment

King Crimson

SBB

Van Der Graaf Generator

Glass Hammer

Colin Tench Project

An Endless Sporadic

Bucium

Rikk Eccent

Genesis

The Flower Kings

Yes

Zwoyld

Cary Grace

Cosmic Ground

Seven Impale

Deep Purple

Lyrian

Dream Theater

Riverside

The Winstons

Camel

Robert Fripp

Disen Gage

Porcupine Tree

Trettioåriga Kriget

Pink Floyd

Poor Genetic Material

Steven Wilson

Manfred Mann's Earth Band

Jethro Tull

Frank Zappa

Rush

Emerson Lake & Palmer

Patto

Renaissance

The Dear Hunter

Metamorfosi

Pineapple Thief

Devin Townsend

Big Big Train

Tangerine Dream

Magma

Steve Hackett

Gong

Iron Maiden

Gentle Giant

ARTISTS:

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

#

VA: SAMPLERS

VA: CONCEPT ALBUMS

VA: TRIBUTES

ALL

MISC:

Top Prog Albums

Top 2015 Albums

Top DVDs

TOP 100 (with MP3)

Videos

Interviews

Gigs Reviews

Active Topics

Review,
MP3,
Video

PROG SHOPPING:

Doug Larson's Imports

LPCDreissues.com

Prog @ Ebay

Prog @ Amazon

Prog @ CDUniverse

Prog Books @ Amazon

<form action="http://www.progarchives.com/google-search-results.asp" id="cse-search-box" style="padding:0px;margin:0px;">

<input type="hidden" name="cof" value="FORID:10"/>
<input type="hidden" name="ie" value="ISO-8859-1"/>
<input type="text" name="q" maxlength="500" value="" id="i_SearchQ_new"/>
<select id="i_SearchOpt_new" name="cx">
<option value="discography">discography</option>
<option value="forum">forum</option>
</select>
<input type="submit" name="sa" id="i_SearchBtn" value="submit"/>

</form>

Progressive Rock Top Albums / all subgenres - all record types - 1973 - all countries

Based on members ratings & PA algorithm

Here is some details about how we calculate the average rating of an album and the rank of an album.

Average rating: The classic calculation of the average but more weight is affected to the rating of progarchives.com collaborators and to rating with reviews.

- Rating only: Weight = 1

- Review by members : Weight = 10

- Review by PA Collaborators : Weight = 20

Rank of an album: We use a calculation that compare an album average rating and number of ratings over all others albums in the query using this theory (http://en.wikipedia.org/wiki/Weighted_average)
 to create a variable every query "QWR" (AKA: Query Weighted Rating) use for ordering.

By default, only albums with the average ratings above the average ratings of the requested query are displayed in theses lists, you can control this value in the parameters

Discuss this in the FORUM

<form action="/top-prog-albums.asp#list" method="get" name="ftop" id="ftop">

TOP list custom links & filters

Customized lists direct links:

TOP Studios of All-Time

TOP 50 "Classic Era" 1967-1975

TOP 2000s

TOP DVD/Videos of All-Time

TOP Live Albums of All-Time

TOP 100 Little Known But Highly Rated Studio Albums of All Time

Filter: By Progressive Rock Sub-Genre

<select name="ssubgenres" size="22" multiple>
<option value="" SELECTED>-- ALL --</option>
<option value="12">Canterbury Scene</option>
<option value="3">Crossover Prog</option>
<option value="42">Eclectic Prog</option>
<option value="44">Experimental/Post Metal</option>
<option value="41">Heavy Prog</option>
<option value="35">Indo-Prog/Raga Rock</option>
<option value="30">Jazz Rock/Fusion</option>
<option value="17">Krautrock</option>
<option value="18">Neo-Prog</option>
<option value="32">Post Rock/Math rock</option>
<option value="6">Prog Folk</option>
<option value="33">Progressive Electronic</option>
<option value="19">Progressive Metal</option>
<option value="15">Psychedelic/Space Rock</option>
<option value="36">RIO/Avant-Prog</option>
<option value="28">Rock Progressivo Italiano</option>
<option value="4">Symphonic Prog</option>
<option value="43">Tech/Extreme Prog Metal</option>
<option value="29">Various Genres</option>
<option value="11">Zeuhl</option>
</select>
(multiple selection, use CTRL key)

Filter: Specify the list recording type

<select name="salbumtypes" multiple>
<option value="1">Studio</option>
<option value="2">DVD/Video</option>
<option value="3">Boxset/Compilation</option>
<option value="4">Live</option>
<option value="5">Singles/EPs/Fan Club/Promo</option>
</select>
(multiple selection, use CTRL key)

Filter: Year of release

<select name="syears" size="10" multiple>
<option value="">-- ALL --</option>
<option value="2016">2016</option>
<option value="2015">2015</option>
<option value="2014">2014</option>
<option value="2013">2013</option>
<option value="2012">2012</option>
<option value="2011">2011</option>
<option value="2010">2010</option>
<option value="2009">2009</option>
<option value="2008">2008</option>
<option value="2007">2007</option>
<option value="2006">2006</option>
<option value="2005">2005</option>
<option value="2004">2004</option>
<option value="2003">2003</option>
<option value="2002">2002</option>
<option value="2001">2001</option>
<option value="2000">2000</option>
<option value="1999">1999</option>
<option value="1998">1998</option>
<option value="1997">1997</option>
<option value="1996">1996</option>
<option value="1995">1995</option>
<option value="1994">1994</option>
<option value="1993">1993</option>
<option value="1992">1992</option>
<option value="1991">1991</option>
<option value="1990">1990</option>
<option value="1989">1989</option>
<option value="1988">1988</option>
<option value="1987">1987</option>
<option value="1986">1986</option>
<option value="1985">1985</option>
<option value="1984">1984</option>
<option value="1983">1983</option>
<option value="1982">1982</option>
<option value="1981">1981</option>
<option value="1980">1980</option>
<option value="1979">1979</option>
<option value="1978">1978</option>
<option value="1977">1977</option>
<option value="1976">1976</option>
<option value="1975">1975</option>
<option value="1974">1974</option>
<option value="1973" SELECTED>1973</option>
<option value="1972">1972</option>
<option value="1971">1971</option>
<option value="1970">1970</option>
<option value="1969">1969</option>
<option value="1968">1968</option>
<option value="1967">1967</option>
<option value="1966">1966</option>
<option value="1965">1965</option>
<option value="1964">1964</option>
<option value="1963">1963</option>
<option value="1962">1962</option>
<option value="1961">1961</option>
<option value="1960">1960</option>
<option value="1959">1959</option>
<option value="1958">1958</option>
<option value="1957">1957</option>
<option value="1956">1956</option>
<option value="1955">1955</option>
<option value="1954">1954</option>
<option value="1953">1953</option>
<option value="1951">1951</option>
<option value="1949">1949</option>
<option value="1948">1948</option>
<option value="1946">1946</option>
<option value="1945">1945</option>
</select>
(multiple selection, use CTRL key)

Filter: Country

<select name="scountries" size="10" multiple>
<option value="" SELECTED>-- ALL --</option>
<option value="6">Andorra</option>
<option value="1">Argentina</option>
<option value="11">Armenia</option>
<option value="13">Australia</option>
<option value="14">Austria</option>
<option value="18">Bahrain</option>
<option value="19">Bangladesh</option>
<option value="21">Belarus</option>
<option value="22">Belgium</option>
<option value="27">Bolivia</option>
<option value="28">Bosnia and Herzegovina</option>
<option value="108">Brazil</option>
<option value="32">Bulgaria</option>
<option value="37">Canada</option>
<option value="42">Chile</option>
<option value="43">China</option>
<option value="46">Colombia</option>
<option value="50">Costa Rica</option>
<option value="52">Croatia</option>
<option value="53">Cuba</option>
<option value="55">Czech Republic</option>
<option value="56">Denmark</option>
<option value="58">Dominican Republic</option>
<option value="60">Ecuador</option>
<option value="61">Egypt</option>
<option value="62">El Salvador</option>
<option value="65">Estonia</option>
<option value="68">Faroe Islands</option>
<option value="70">Finland</option>
<option value="71">France</option>
<option value="76">Georgia</option>
<option value="77">Germany</option>
<option value="78">Ghana</option>
<option value="80">Greece</option>
<option value="83">Guadeloupe</option>
<option value="85">Guatemala</option>
<option value="91">Hungary</option>
<option value="92">Iceland</option>
<option value="93">India</option>
<option value="94">Indonesia</option>
<option value="95">Iran</option>
<option value="96">Iraq</option>
<option value="97">Ireland</option>
<option value="98">Israel</option>
<option value="99">Italy</option>
<option value="101">Japan</option>
<option value="109">Kuwait</option>
<option value="112">Latvia</option>
<option value="113">Lebanon</option>
<option value="118">Lithuania</option>
<option value="119">Luxembourg</option>
<option value="220">Macedonia</option>
<option value="121">Madagascar</option>
<option value="123">Malaysia</option>
<option value="126">Malta</option>
<option value="132">Mexico</option>
<option value="134">Moldova</option>
<option value="135">Monaco</option>
<option value="219">Montenegro</option>
<option value="210">Multi-National</option>
<option value="145">Netherlands</option>
<option value="147">New Zealand</option>
<option value="148">Nicaragua</option>
<option value="153">Norway</option>
<option value="155">Pakistan</option>
<option value="157">Panama</option>
<option value="160">Peru</option>
<option value="161">Philippines</option>
<option value="162">Poland</option>
<option value="163">Portugal</option>
<option value="164">Puerto Rico</option>
<option value="167">Romania</option>
<option value="168">Russia</option>
<option value="218">Serbia</option>
<option value="211">Slovakia</option>
<option value="212">Slovenia</option>
<option value="215">South Africa</option>
<option value="207">Spain</option>
<option value="178">Sweden</option>
<option value="179">Switzerland</option>
<option value="180">Syria</option>
<option value="189">Tunisia</option>
<option value="190">Turkey</option>
<option value="191">Turkmenistan</option>
<option value="194">Ukraine</option>
<option value="195">United Arab Emirates</option>
<option value="206">United Kingdom</option>
<option value="197">United States</option>
<option value="198">Uruguay</option>
<option value="199">Uzbekistan</option>
<option value="140">Various</option>
<option value="200">Venezuela</option>
<option value="203">Yugoslavia</option>
</select>
(multiple selection, use CTRL key)

Filter: Minimum Number of Ratings

<input type="text" name="sminratings" value="0" size="4" maxlength="4"> 0 for avg. number of ratings

Filter: Maximum Number of Ratings

<input type="text" name="smaxratings" value="0" size="4" maxlength="4"> 0 for unlimited

Filter: Minimum Average Rating Value

<input type="text" name="sminavgratings" value="0" size="3" maxlength="3"> 0 for average ratings in query

Filter: Maximum Results

<input type="text" name="smaxresults" value="250" size="3" maxlength="3"> (Max=250)

<input type="image" src="/static-images/btn_Submit.gif">

</form>

Rank
Cover
Ratings
Title
Artist
Genre
(Record Type)
BUY

1

4.63 | 3534 ratings

QWR = 4.5890

Selling England By The Pound
Genesis
Symphonic Prog
Studio, 1973
Shop

2

4.60 | 3678 ratings

QWR = 4.5621

Dark Side Of The Moon
Pink Floyd
Psychedelic/Space Rock
Studio, 1973
Shop

3

4.41 | 2381 ratings

QWR = 4.3710

Larks' Tongues In Aspic
King Crimson
Eclectic Prog
Studio, 1973
Shop

4

4.35 | 1382 ratings

QWR = 4.2853

In A Glass House
Gentle Giant
Eclectic Prog
Studio, 1973
Shop

5

4.37 | 862 ratings

QWR = 4.2676

Io Sono Nato Libero
Banco Del Mutuo Soccorso
Rock Progressivo Italiano
Studio, 1973
Shop

6

4.33 | 1071 ratings

QWR = 4.2477

Birds Of Fire
Mahavishnu Orchestra
Jazz Rock/Fusion
Studio, 1973
Shop

7

4.31 | 780 ratings

QWR = 4.2024

Mekanïk Destruktïw Kommandöh
Magma
Zeuhl
Studio, 1973
Shop

8

4.30 | 698 ratings

QWR = 4.1815

Zarathustra
Museo Rosenbach
Rock Progressivo Italiano
Studio, 1973
Shop

9

4.26 | 629 ratings

QWR = 4.1401

Hatfield And The North
Hatfield And The North
Canterbury Scene
Studio, 1973
Shop

10

4.28 | 526 ratings

QWR = 4.1350

Arbeit Macht Frei
Area
Rock Progressivo Italiano
Studio, 1973
Shop

11

4.23 | 761 ratings

QWR = 4.1321

Felona E Sorona
Le Orme
Rock Progressivo Italiano
Studio, 1973
Shop

12

4.28 | 465 ratings

QWR = 4.1237

Spectrum
Billy Cobham
Jazz Rock/Fusion
Studio, 1973
Shop

13

4.22 | 603 ratings

QWR = 4.0993

Ashes Are Burning
Renaissance
Symphonic Prog
Studio, 1973
Shop

14

4.12 | 1582 ratings

QWR = 4.0798

Brain Salad Surgery
Emerson Lake & Palmer
Symphonic Prog
Studio, 1973
Shop

15

4.15 | 604 ratings

QWR = 4.0412

For Girls Who Grow Plump In The Night
Caravan
Canterbury Scene
Studio, 1973
Shop

16

4.07 | 945 ratings

QWR = 4.0083

Tubular Bells
Mike Oldfield
Crossover Prog
Studio, 1973
Shop

17

4.11 | 555 ratings

QWR = 4.0035

Radio Gnome Invisible Vol. 2 - Angel's Egg
Gong
Canterbury Scene
Studio, 1973
Shop

18

4.07 | 679 ratings

QWR = 3.9817

The Six Wives of Henry VIII
Rick Wakeman
Symphonic Prog
Studio, 1973
Shop

19

4.21 | 236 ratings

QWR = 3.9744

Måltid
Samla Mammas Manna
RIO/Avant-Prog
Studio, 1973
Shop

20

4.02 | 1214 ratings

QWR = 3.9716

A Passion Play
Jethro Tull
Prog Folk
Studio, 1973
Shop

21

4.16 | 266 ratings

QWR = 3.9569

Hymn Of The Seventh Galaxy
Return To Forever
Jazz Rock/Fusion
Studio, 1973
Shop

22

4.08 | 442 ratings

QWR = 3.9538

Photos Of Ghosts
Premiata Forneria Marconi (PFM)
Rock Progressivo Italiano
Studio, 1973
Shop

23

4.16 | 253 ratings

QWR = 3.9484

Contaminazione
Il Rovescio Della Medaglia
Rock Progressivo Italiano
Studio, 1973
Shop

24

4.06 | 468 ratings

QWR = 3.9474

Future Days
Can
Krautrock
Studio, 1973
Shop

25

4.03 | 509 ratings

QWR = 3.9306

The Mothers Of Invention: Over-Nite Sensation
Frank Zappa
RIO/Avant-Prog
Studio, 1973
Shop

26

4.09 | 281 ratings

QWR = 3.9182

Alphataurus
Alphataurus
Rock Progressivo Italiano
Studio, 1973
Shop

27

3.95 | 1089 ratings

QWR = 3.9070

Camel
Camel
Symphonic Prog
Studio, 1973
Shop

28

4.13 | 205 ratings

QWR = 3.8990

Legend
Henry Cow
RIO/Avant-Prog
Studio, 1973
Shop

29

4.20 | 155 ratings

QWR = 3.8962

Melos
Cervello
Rock Progressivo Italiano
Studio, 1973
Shop

30

4.03 | 296 ratings

QWR = 3.8798

Chameleon In The Shadow Of The Night
Peter Hammill
Eclectic Prog
Studio, 1973
Shop

31

3.89 | 2075 ratings

QWR = 3.8709

Tales From Topographic Oceans
Yes
Symphonic Prog
Studio, 1973
Shop

32

4.05 | 240 ratings

QWR = 3.8692

Dedicato a Frazz
Semiramis
Rock Progressivo Italiano
Studio, 1973
Shop

33

4.04 | 248 ratings

QWR = 3.8685

For Your Pleasure
Roxy Music
Crossover Prog
Studio, 1973
Shop

34

4.01 | 279 ratings

QWR = 3.8582

Solar Fire
Manfred Mann's Earth Band
Eclectic Prog
Studio, 1973
Shop

35

3.91 | 457 ratings

QWR = 3.8253

Radio Gnome Invisible Part 1 - Flying Teapot
Gong
Canterbury Scene
Studio, 1973
Shop

36

4.08 | 142 ratings

QWR = 3.8148

Sextant
Herbie Hancock
Jazz Rock/Fusion
Studio, 1973
Shop

37

4.12 | 120 ratings

QWR = 3.8104

Vietato ai Minori di 18 Anni
Jumbo
Rock Progressivo Italiano
Studio, 1973
Shop

38

3.98 | 201 ratings

QWR = 3.8037

Inferno
Metamorfosi
Rock Progressivo Italiano
Studio, 1973
Shop

39

3.88 | 402 ratings

QWR = 3.7925

Remember The Future
Nektar
Psychedelic/Space Rock
Studio, 1973
Shop

40

4.00 | 151 ratings

QWR = 3.7784

Countdown To Ecstasy
Steely Dan
Jazz Rock/Fusion
Studio, 1973
Shop

41

3.92 | 171 ratings

QWR = 3.7460

Clearlight Symphony
Clearlight
Symphonic Prog
Studio, 1973
Shop

42

3.88 | 196 ratings

QWR = 3.7392

Grand Hotel
Procol Harum
Crossover Prog
Studio, 1973
Shop

43

3.85 | 174 ratings

QWR = 3.7095

Head Hunters
Herbie Hancock
Jazz Rock/Fusion
Studio, 1973
Shop

44

3.84 | 165 ratings

QWR = 3.6999

Future Legends
Fruupp
Symphonic Prog
Studio, 1973
Shop

45

3.75 | 397 ratings

QWR = 3.6964

3
Focus
Symphonic Prog
Studio, 1973
Shop

46

3.86 | 134 ratings

QWR = 3.6909

Join Inn
Ash Ra Tempel
Krautrock
Studio, 1973
Shop

47

3.75 | 349 ratings

QWR = 3.6907

Inside
Eloy
Psychedelic/Space Rock
Studio, 1973
Shop

48

3.80 | 201 ratings

QWR = 3.6879

On The Third Day
Electric Light Orchestra
Crossover Prog
Studio, 1973
Shop

49

3.82 | 155 ratings

QWR = 3.6813

Campo Di Marte
Campo di Marte
Rock Progressivo Italiano
Studio, 1973
Shop

50

3.80 | 159 ratings

QWR = 3.6709

Second
Agitation Free
Krautrock
Studio, 1973
Shop

51

3.82 | 137 ratings

QWR = 3.6699

Shoot Out at the Fantasy Factory
Traffic
Eclectic Prog
Studio, 1973
Shop

52

3.72 | 169 ratings

QWR = 3.6272

Here Come The Warm Jets
Brian Eno
Progressive Electronic
Studio, 1973
Shop

53

3.69 | 119 ratings

QWR = 3.5975

Air Cut
Curved Air
Eclectic Prog
Studio, 1973
Shop

54

3.62 | 209 ratings

QWR = 3.5750

Seven
The Soft Machine
Canterbury Scene
Studio, 1973
Shop

55

3.57 | 253 ratings

QWR = 3.5492

Atem
Tangerine Dream
Progressive Electronic
Studio, 1973
Shop

56

3.58 | 145 ratings

QWR = 3.5463

Stranded
Roxy Music
Crossover Prog
Studio, 1973
Shop

57

3.55 | 175 ratings

QWR = 3.5296

Greenslade
Greenslade
Symphonic Prog
Studio, 1973
Shop

58

3.54 | 135 ratings

QWR = 3.5249

Bursting At The Seams
Strawbs
Prog Folk
Studio, 1973
Shop

Copyright Prog Archives, All rights reserved. | Legal Notice | Privacy Policy | Advertise | RSS + syndications

Other sites in the MAC network: JazzMusicArchives.com — jazz music reviews and archives | MetalMusicArchives.com — metal music reviews and archives


text:
package at.ac.tuwien.dsg.myx.monitor.em.events;

public interface XADLHostProperties {
    String CPU_SYSTEM_LOAD = "cpu-system-load";
    String CPU_PROCESS_LOAD = "cpu-process-load";

    String MEMORY_HEAP_USED = "memory-heap-used";
    String MEMORY_HEAP_FREE = "memory-heap-free";
    String MEMORY_NON_HEAP_USED = "memory-non-heap-used";
    String MEMORY_NON_HEAP_FREE = "memory-non-heap-free";
}


text:
#include <algorithm>
#include <locale>
#include <string>

#include "absl/strings/ascii.h"
#include "absl/strings/str_cat.h"
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/op_requires.h"
#include "tensorflow/core/platform/errors.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace text {

namespace {
template <typename SPLITS_TYPE>
class StringNGramsOp : public tensorflow::OpKernel {
 public:
  explicit StringNGramsOp(tensorflow::OpKernelConstruction* context)
      : tensorflow::OpKernel(context) {
    OP_REQUIRES_OK(context, context->GetAttr("separator", &separator_));
    OP_REQUIRES_OK(context, context->GetAttr("ngram_widths", &ngram_widths_));
    OP_REQUIRES_OK(context, context->GetAttr("left_pad", &left_pad_));
    OP_REQUIRES_OK(context, context->GetAttr("right_pad", &right_pad_));
    OP_REQUIRES_OK(context, context->GetAttr("pad_width", &pad_width_));
    OP_REQUIRES_OK(context, context->GetAttr("preserve_short_sequences",
                                             &preserve_short_));
  }

  int get_pad_width(const int ngram_width) const {
    // Ngrams can be padded with either a fixed pad width or a dynamic pad
    // width depending on the 'pad_width' arg, but in no case should the padding
    // ever be wider than 'ngram_width' - 1.
    return std::min(pad_width_ < 0 ? ngram_width - 1 : pad_width_,
                    ngram_width - 1);
  }

  StatusOr<int> get_num_ngrams(const int length, const int ngram_width) const {
    int64 limit = kint32max;
    int pad_width = get_pad_width(ngram_width);
    if (pad_width > limit / 2 - length) {
      return errors::InvalidArgument(
          "Pad width could lead to integer overflow, got pad_width = ",
          pad_width);
    }
    return std::max(0, ((length + 2 * pad_width) - ngram_width) + 1);
  }

  void Compute(tensorflow::OpKernelContext* context) override {
    for (int ngram_width : ngram_widths_) {
      OP_REQUIRES(
          context, ngram_width > 0,
          errors::InvalidArgument("ngram_widths must contain positive values"));
    }

    const tensorflow::Tensor* data;
    OP_REQUIRES_OK(context, context->input("data", &data));
    const auto& input_data = data->flat<tstring>().data();

    const tensorflow::Tensor* splits;
    OP_REQUIRES_OK(context, context->input("data_splits", &splits));
    const auto& splits_vec = splits->flat<SPLITS_TYPE>();

    // Validate that the splits are valid indices into data, only if there are
    // splits specified.
    const int input_data_size = data->flat<tstring>().size();
    const int splits_vec_size = splits_vec.size();
    if (splits_vec_size > 0) {
      int prev_split = splits_vec(0);
      OP_REQUIRES(context, prev_split == 0,
                  errors::InvalidArgument("First split value must be 0, got ",
                                          prev_split));
      for (int i = 1; i < splits_vec_size; ++i) {
        bool valid_splits = splits_vec(i) >= prev_split;
        valid_splits = valid_splits && (splits_vec(i) <= input_data_size);
        OP_REQUIRES(context, valid_splits,
                    errors::InvalidArgument(
                        "Invalid split value ", splits_vec(i), ", must be in [",
                        prev_split, ", ", input_data_size, "]"));
        prev_split = splits_vec(i);
      }
      OP_REQUIRES(context, prev_split == input_data_size,
                  errors::InvalidArgument(
                      "Last split value must be data size. Expected ",
                      input_data_size, ", got ", prev_split));
    }

    int num_batch_items = splits_vec.size() - 1;
    tensorflow::Tensor* ngrams_splits;
    OP_REQUIRES_OK(
        context, context->allocate_output(1, splits->shape(), &ngrams_splits));
    auto ngrams_splits_data = ngrams_splits->flat<SPLITS_TYPE>().data();

    // If there is no data or size, return an empty RT.
    if (data->flat<tstring>().size() == 0 || splits_vec.size() == 0) {
      tensorflow::Tensor* empty;
      OP_REQUIRES_OK(context,
                     context->allocate_output(0, data->shape(), &empty));
      for (int i = 0; i <= num_batch_items; ++i) {
        ngrams_splits_data[i] = 0;
      }
      return;
    }

    ngrams_splits_data[0] = 0;
    for (int i = 1; i <= num_batch_items; ++i) {
      int length = splits_vec(i) - splits_vec(i - 1);
      int num_ngrams = 0;
      for (int ngram_width : ngram_widths_) {
        auto ngrams_or = get_num_ngrams(length, ngram_width);
        OP_REQUIRES_OK(context, ngrams_or.status());
        num_ngrams += ngrams_or.value();
      }
      if (preserve_short_ && length > 0 && num_ngrams == 0) {
        num_ngrams = 1;
      }
      ngrams_splits_data[i] = ngrams_splits_data[i - 1] + num_ngrams;
    }

    tensorflow::Tensor* ngrams;
    OP_REQUIRES_OK(
        context,
        context->allocate_output(
            0, TensorShape({ngrams_splits_data[num_batch_items]}), &ngrams));
    auto ngrams_data = ngrams->flat<tstring>().data();

    for (int i = 0; i < num_batch_items; ++i) {
      auto data_start = &input_data[splits_vec(i)];
      int output_start_idx = ngrams_splits_data[i];
      for (int ngram_width : ngram_widths_) {
        auto output_start = &ngrams_data[output_start_idx];
        int length = splits_vec(i + 1) - splits_vec(i);
        auto ngrams_or = get_num_ngrams(length, ngram_width);
        OP_REQUIRES_OK(context, ngrams_or.status());
        int num_ngrams = ngrams_or.value();
        CreateNgrams(data_start, output_start, num_ngrams, ngram_width);
        output_start_idx += num_ngrams;
      }
      // If we're preserving short sequences, check to see if no sequence was
      // generated by comparing the current output start idx to the original
      // one (ngram_splits_data). If no ngrams were generated, then they will
      // be equal (since we increment output_start_idx by num_ngrams every
      // time we create a set of ngrams.)
      if (preserve_short_ && output_start_idx == ngrams_splits_data[i]) {
        int data_length = splits_vec(i + 1) - splits_vec(i);
        // One legitimate reason to not have any ngrams when preserve_short_
        // is true is if the sequence itself is empty. In that case, move on.
        if (data_length == 0) {
          continue;
        }
        // We don't have to worry about dynamic padding sizes here: if padding
        // was dynamic, every sequence would have had sufficient padding to
        // generate at least one ngram.

        // If reached here, pad_width should be > 0, pad_width_ = -1,
        // which indicates max(ngram_widths) - 1 cannot be used here since
        // ngram_width is not known.
        OP_REQUIRES(
            context, pad_width_ >= 0,
            errors::InvalidArgument("Pad width should be >= 0 when "
                                    "preserve_short_sequences is True and "
                                    "ngram_widths are not provided, got ",
                                    pad_width_));
        int ngram_width = data_length + 2 * pad_width_;
        auto output_start = &ngrams_data[output_start_idx];
        int num_ngrams = 1;
        CreateNgrams(data_start, output_start, num_ngrams, ngram_width);
      }
    }
  }

  void CreateNgrams(const tstring* data, tstring* output, int num_ngrams,
                    int ngram_width) const {
    for (int ngram_index = 0; ngram_index < num_ngrams; ++ngram_index) {
      int pad_width = get_pad_width(ngram_width);
      int left_padding = std::max(0, pad_width - ngram_index);
      int right_padding =
          std::max(0, pad_width - (num_ngrams - (ngram_index + 1)));
      int num_tokens = ngram_width - (left_padding + right_padding);
      int data_start_index = left_padding > 0 ? 0 : ngram_index - pad_width;

      // Calculate the total expected size of the ngram so we can reserve the
      // correct amount of space in the string.
      int ngram_size = 0;
      // Size of the left padding.
      ngram_size += left_padding * left_pad_.length();
      // Size of the tokens.
      for (int n = 0; n < num_tokens; ++n) {
        ngram_size += data[data_start_index + n].length();
      }
      // Size of the right padding.
      ngram_size += right_padding * right_pad_.length();
      // Size of the separators.
      int num_separators = left_padding + right_padding + num_tokens - 1;
      ngram_size += num_separators * separator_.length();

      // Build the ngram.
      tstring* ngram = &output[ngram_index];
      ngram->reserve(ngram_size);
      for (int n = 0; n < left_padding; ++n) {
        ngram->append(left_pad_);
        ngram->append(separator_);
      }
      // Only output first num_tokens - 1 pairs of data and separator
      for (int n = 0; n < num_tokens - 1; ++n) {
        ngram->append(data[data_start_index + n]);
        ngram->append(separator_);
      }
      // Handle case when there are no tokens or no right padding as these can
      // result in consecutive separators.
      if (num_tokens > 0) {
        // If we have tokens, then output last and then pair each separator with
        // the right padding that follows, to ensure ngram ends either with the
        // token or with the right pad.
        ngram->append(data[data_start_index + num_tokens - 1]);
        for (int n = 0; n < right_padding; ++n) {
          ngram->append(separator_);
          ngram->append(right_pad_);
        }
      } else {
        // If we don't have tokens, then the last item inserted into the ngram
        // has been the separator from the left padding loop above. Hence,
        // output right pad and separator and make sure to finish with a
        // padding, not a separator.
        for (int n = 0; n < right_padding - 1; ++n) {
          ngram->append(right_pad_);
          ngram->append(separator_);
        }
        ngram->append(right_pad_);
      }

      // In debug mode only: validate that we've reserved enough space for the
      // ngram.
      DCHECK_EQ(ngram_size, ngram->size());
    }
  }

  string separator_;
  string left_pad_;
  string right_pad_;
  bool use_pad_;
  bool extend_pad_;
  bool preserve_short_;

  std::vector<int> ngram_widths_;
  int pad_width_;
};

}  // namespace
REGISTER_KERNEL_BUILDER(Name("StringNGrams")
                            .Device(tensorflow::DEVICE_CPU)
                            .TypeConstraint<int32>("Tsplits"),
                        StringNGramsOp<int32>);
REGISTER_KERNEL_BUILDER(Name("StringNGrams")
                            .Device(tensorflow::DEVICE_CPU)
                            .TypeConstraint<int64_t>("Tsplits"),
                        StringNGramsOp<int64_t>);

}  // namespace text
}  // namespace tensorflow


text:
from ..core import *
from ..core.packet import Tag
from ..ext import param, Paramed

import time

from collections import defaultdict
from heapq import merge
from pyadds.logging import log
from ..compat import JoinableQueue

class Timing:
    def __init__(self):
        self.time = self.start = time.time()

    def set(self, now=None):
        if now is None:
            now = time.time()
        self.time = now - self.start

    @property
    def mins(self):
        return int(self.time // 60) % 60

    @property
    def hours(self):
        return int(self.time // 3600)

    @property
    def secs(self):
        return self.time % 60

    def __getitem__(self, name):
        if isinstance(name, str):
            return {'time': self.time, 'mins': self.mins, 'hours': self.hours, 'secs': self.secs}[name]
        elif isinstance(name, int):
            return {-1: self.time, 0: self.secs, 1: self.mins, 2: self.hours}
        elif isinstance(name, tuple):
            return tuple(self[n] for n in name)
        raise KeyError('Timing has no item %s' % name)

    def __iter__(self):
        return iter((self.hours, self.mins, self.secs))

    def __float__(self):
        return self.time

    def __str__(self):
        if self.hours:
            return '{}:{:02d}:{:02.0f}'.format(*self)
        else:
            return '{}:{:04.1f}'.format(*self['mins','secs'])

class Status(Paramed, Unit):
    @param
    def format(self, val='{__tag__!r}'):
        return val

    @param
    def end(self, val='\n'):
        return val

    @coroutine
    def __setup__(self):
        self.timing = Timing()

    @inport
    def process(self, data, tag):
        self.timing.set()
        try:
            length = len(data)
        except Exception:
            length = None
        print(self.format.format(__data__=data,
                                 __len__=length,
                                 __tag__=tag,
                                 __time__=self.timing,
                                 **tag), end=self.end, flush=True)
        yield from []

def ensure(val, typ):
    return val if isinstance(val, typ) else typ([val])

class match(Unit):
    def __init__(self, **matches):
        super().__init__()
        self.matches = {k: ensure(v, set) for k,v in matches.items()}

    @outport
    def out(): pass

    @inport
    def process(self, data, tag):
        if all(tag[key] in val for key,val in self.matches.items()):
            yield from data >> tag >> self.out

class Categorize(Paramed, Unit):
    @param
    def tag(self, val='category'):
        return val

    @param
    def rules(self, val):
        return [(cat, [{k: ensure(v, set) for k,v in rule.items()}
                       for rule in ensure(rules, list)])
                for cat, rules in val.items()]

    @param
    def default(self, val=None):
        return val

    @outport
    def out(): pass

    @outport
    def non(): pass

    @inport
    def process(self, data, tag):
        for cat, rules in self.rules:
            if any(all(tag[key] in val for key, val in rule.items())
                   for rule in rules):
                break
        else:
            cat = self.default

        if cat is None:
            yield from data >> tag >> self.non
        else:
            yield from data >> tag.add(**{self.tag: cat}) >> self.out

class forward(Unit):
    @outport
    def out(): pass

    @inport
    def process(self, data, tag):
        yield from data >> tag >> self.out

class addtag(Unit):
    def __init__(self, **tag):
        super().__init__()
        self.tag = tag

    @outport
    def out(): pass

    @inport
    def process(self, data, tag):
        yield from data >> tag.add(**self.tag) >> self.out

class tagonly(Unit):
    @outport
    def out(): pass

    @inport
    def process(self, _, tag):
        yield from None >> tag >> self.out

class Offset(Unit):
    @outport
    def out(): pass

    @coroutine
    def __setup__(self):
        self.offset = 0

    @inport
    def process(self, data, tag):
        yield from data >> tag.add(offset=offset) >> self.out
        self.offset += len(data)

@log
class Merge(Paramed, Unit):
    @param
    def by(self, val='begin'):
        return val

    @outport
    def out(): pass

    @coroutine
    def __setup__(self):
        self.queue_a = JoinableQueue(1)
        self.queue_b = JoinableQueue(1)
        asyncio.async(self.loop())

    @coroutine
    def __teardown__(self):
        self.__log.info('tearing down %s', self)
        qs = [self.queue_a, self.queue_b]
        yield from asyncio.gather(*[q.put((None, None, None)) for q in qs])
        yield from asyncio.gather(*[q.join() for q in qs])
        self.__log.info('tear down of %s finished', self)

    @coroutine
    def loop(self):
        queue_a, queue_b = self.queue_a, self.queue_b
        fill_a = fill_b = True
        while True:
            if fill_a:
                val_a, data_a, tag_a = yield from queue_a.get()
                fill_a = False
                self.__log.debug('got data form a')
            if fill_b:
                val_b, data_b, tag_b = yield from queue_b.get()
                fill_b = False
                self.__log.debug('got data form b')

            if val_a is None and val_b is None:
                self.__log.info('shuting down %s', self)
                queue_a.task_done()
                queue_b.task_done()
                break
            elif val_a == val_b:
                data = list(merge(data_a + data_b))
                tag = tag_b.add(**tag_a)
                fill_a = fill_b = True
                self.__log.debug('pushing both')
            elif val_b is None or val_a is not None and val_a < val_b:
                data, tag = data_a, tag_a
                fill_a = True
                self.__log.debug('pushing a')
            elif val_a is None or val_b < val_a:
                data, tag = data_b, tag_b
                fill_b = True
                self.__log.debug('pushing b')
            else:
                assert false, "wabus brain messed up"

            yield from data >> tag >> self.out

            if fill_a:
                queue_a.task_done()
            if fill_b:
                queue_b.task_done()

    @inport
    def a(self, data, tag):
        self.__log.debug('received on a')
        yield from self.queue_a.put((tag[self.by], data, tag))

    @inport
    def b(self, data, tag):
        self.__log.debug('received on b')
        yield from self.queue_b.put((tag[self.by], data, tag))

class Reorder(Paramed, Unit):
    @param
    def by(self, val='path'):
        return val

    @param
    def max(self, val=0):
        return val

    @outport
    def out(): pass

    @coroutine
    def __setup__(self):
        self.orders = []
        self.queued = defaultdict(list)

    @coroutine
    def push(self):
        queued = self.queued
        orders = self.orders
        while orders:
            q = queued[orders[0]]
            if not q:
                break

            load, tag = q.pop(0)
            yield from load >> tag >> self.out

            if tag.flush:
                if queued[orders[0]]:
                    raise
                queued.pop(orders[0])
                orders.pop(0)

    @inport
    def order(self, _, tag):
        self.orders.append(tag[self.by])
        yield from self.push()

    @inport
    def process(self, load, tag):
        self.queued[tag[self.by]].append((load,tag))
        yield from self.push()

@log
class Collect(Paramed, Unit):
    @param
    def warmup(self, warmup=128):
            return warmup

    @param
    def number(self, number=4):
        """ collect at least this number of packets """
        return number

    @param
    def length(self, length='4k'):
        """ collect until we have at least this length """
        return param.sizeof(length)

    @param
    def timeout(self, timeout=.1):
        """ wait at most this time before putting out """
        return timeout

    @param
    def max_queued(self, max_queued=4):
        """ maximum number of queued packets """
        return max_queued

    @param
    def collectby(self, collectby=None):
        return collectby

    @param
    def flush(self, value=True):
        return value

    @outport
    def out(self, data, tag):
        pass

    @coroutine
    def __setup__(self):
        self.queues = {}

    @coroutine
    def __teardown__(self):
        yield from asyncio.gather(*[q.put((None, None)) for q in self.queues.values()])

    def reduce(self, datas):
        return b''.join(datas)

    @coroutine
    def pusher(self, q):
        datas = []
        timeout = self.timeout
        length = self.length
        number = self.number
        total = 0
        count = 0
        tag = Tag()
        first = None
        warmup = self.warmup

        reduce = self.reduce
        #release = ctx.release

        while True:
            flush = False

            if datas:
                try:
                    data,t = yield from asyncio.wait_for(q.get(),
                            first + timeout - time.time())
                except asyncio.TimeoutError:
                    flush = True
            else:
                data,t = yield from q.get()
                first = time.time()

            if t is None and data is None and self.flush:
                flush = True

            if not flush and t is not None:
                tag.update(t)
                datas.append(data)
                total += len(data)
                count += 1

            if warmup:
                warmup -= 1
                count = number

            if flush or count > number or total > length or t is None or tag.flush:
                if datas:
                    out = reduce(datas)
                    yield from out >> tag.add(
                            collected_num = len(datas),
                            collected_delta = time.time() - first
                            ) >> self.out
                    #yield from ctx.release(count)
                    total = count = 0
                    datas=[]
                    tag = Tag()

            if not flush and t is None:
                break

    @inport
    def process(self, data, tag):
        #ctx = self.ctx
        #yield from ctx.aquire()

        by = tag.get(self.collectby)
        try:
            q = self.queues[by]
        except KeyError:
            self.__log.info('new queue for %s', by)
            q = asyncio.Queue(self.max_queued)
            asyncio.async(self.pusher(q))
            self.queues[by] = q

        yield from q.put((data, tag))


text:
package com.intellij.find.findUsages;

import com.intellij.internal.statistic.eventLog.FeatureUsageData;
import com.intellij.internal.statistic.service.fus.collectors.FUCounterUsageLogger;
import com.intellij.java.JavaBundle;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.ui.panel.ComponentPanelBuilder;
import com.intellij.psi.*;
import com.intellij.psi.search.searches.ImplicitToStringSearch;
import com.intellij.ui.StateRestoringCheckBox;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;

public class FindMethodUsagesDialog extends JavaFindUsagesDialog<JavaMethodFindUsagesOptions> {
  private StateRestoringCheckBox myCbSearchForBase;
  private StateRestoringCheckBox myCbUsages;
  private StateRestoringCheckBox myCbImplementingMethods;
  private StateRestoringCheckBox myCbOverridingMethods;
  private StateRestoringCheckBox myCbImplicitToString;
  private boolean myHasFindWhatPanel;

  public FindMethodUsagesDialog(PsiElement element, Project project, FindUsagesOptions findUsagesOptions,
                                boolean toShowInNewTab, boolean mustOpenInNewTab, boolean isSingleFile, FindUsagesHandler handler) {
    super(element, project, findUsagesOptions, toShowInNewTab, mustOpenInNewTab, isSingleFile, handler);
  }

  @Override
  @Nullable
  public JComponent getPreferredFocusedControl() {
    return myHasFindWhatPanel ? myCbUsages : null;
  }

  @Override
  public void calcFindUsagesOptions(JavaMethodFindUsagesOptions options) {
    super.calcFindUsagesOptions(options);

    options.isUsages = isSelected(myCbUsages) || !myHasFindWhatPanel;
    if (isToChange(myCbSearchForBase)) {
      options.isSearchForBaseMethod = isSelected(myCbSearchForBase);
    }
    if (isToChange(myCbOverridingMethods)) {
      options.isOverridingMethods = isSelected(myCbOverridingMethods);
    }
    if (isToChange(myCbImplementingMethods)) {
      options.isImplementingMethods = isSelected(myCbImplementingMethods);
    }
    if (isToChange(myCbImplicitToString)) {
      options.isImplicitToString = isSelected(myCbImplicitToString);
    }
    options.isCheckDeepInheritance = true;
    FUCounterUsageLogger.getInstance().logEvent(myPsiElement.getProject(), EVENT_LOG_GROUP, "find.method.started", createFeatureUsageData(options));
  }

  @Override
  protected FeatureUsageData createFeatureUsageData(JavaMethodFindUsagesOptions options) {
    FeatureUsageData data = super.createFeatureUsageData(options);
    data.addData("searchForBaseMethods", options.isSearchForBaseMethod);
    data.addData("overridingMethods", options.isOverridingMethods);
    data.addData("implementingMethods", options.isImplementingMethods);
    data.addData("includeInherited", options.isIncludeInherited);
    data.addData("includeOverload", options.isIncludeOverloadUsages);
    data.addData("implicitCalls", options.isImplicitToString);
    return data;
  }

  @Override
  protected JPanel createFindWhatPanel() {
    JPanel findWhatPanel = new JPanel();
    findWhatPanel.setLayout(new BoxLayout(findWhatPanel, BoxLayout.Y_AXIS));

    myCbUsages = addCheckboxToPanel(JavaBundle.message("find.what.usages.checkbox"), getFindUsagesOptions().isUsages, findWhatPanel, true);

    PsiMethod method = (PsiMethod) getPsiElement();
    PsiClass aClass = method.getContainingClass();
    if (aClass == null) {
      myHasFindWhatPanel = false;
      return null;
    }

    if (!method.hasModifierProperty(PsiModifier.STATIC) &&
        !method.hasModifierProperty(PsiModifier.PRIVATE) &&
        !method.isConstructor()) {
      myCbSearchForBase = createCheckbox(JavaBundle.message("find.what.search.for.base.methods.checkbox"),
                                         getFindUsagesOptions().isSearchForBaseMethod, true);

      JComponent decoratedCheckbox = new ComponentPanelBuilder(myCbSearchForBase).
        withComment(JavaBundle.message("find.what.search.for.base.methods.checkbox.comment")).createPanel();
      decoratedCheckbox.setAlignmentX(Component.LEFT_ALIGNMENT);
      findWhatPanel.add(decoratedCheckbox);
    }

    if (method.hasModifierProperty(PsiModifier.ABSTRACT)) {
      myCbImplementingMethods = addCheckboxToPanel(JavaBundle.message("find.what.implementing.methods.checkbox"),
                                                    getFindUsagesOptions().isImplementingMethods, findWhatPanel, true);
    }
    else if (!(aClass instanceof PsiAnonymousClass) &&
             !aClass.hasModifierProperty(PsiModifier.FINAL) &&
             !method.isConstructor() &&
             !method.hasModifierProperty(PsiModifier.FINAL) &&
             !method.hasModifierProperty(PsiModifier.STATIC) &&
             !method.hasModifierProperty(PsiModifier.PRIVATE)) {
      myCbOverridingMethods = addCheckboxToPanel(JavaBundle.message("find.what.overriding.methods.checkbox"),
                                                 getFindUsagesOptions().isOverridingMethods, findWhatPanel, true);
    }
    if (ImplicitToStringSearch.isToStringMethod(method)) {
      myCbImplicitToString = addCheckboxToPanel(JavaBundle.message("find.what.implicit.to.string.checkbox"),
                                                getFindUsagesOptions().isImplicitToString, findWhatPanel, true);
    }

    myHasFindWhatPanel = true;
    return findWhatPanel;
  }

  @Override
  protected void update() {
    if (!myHasFindWhatPanel) {
      setOKActionEnabled(true);
    } else {
      boolean hasSelected = isSelected(myCbUsages) ||
                            isSelected(myCbSearchForBase) ||
                            isSelected(myCbImplementingMethods) ||
                            isSelected(myCbOverridingMethods) ||
                            isSelected(myCbImplicitToString);
      setOKActionEnabled(hasSelected);
    }
  }
}


text:
package randoop;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.List;

import randoop.sequence.Sequence;
import randoop.util.CollectionsExt;
import randoop.util.Log;

/**
 * Outputs a collection of sequences as Java files, with one method per
 * sequence.
 */
public class JavaFileWriter {

  // Creates Junit tests for the faults.
  // Output is a set of .java files.
  public static void createJavaFiles(
      List<Sequence> sequences, String junitClassName, int testsPerFile) {
    if (sequences.size() == 0) {
      System.out.println("No sequences given to createJavaFiles. No files created.");
      return;
    }

    List<List<Sequence>> subSuites = CollectionsExt.<Sequence>chunkUp(sequences, testsPerFile);
    for (int i = 0; i < subSuites.size(); i++) {
      writeSubSuite(subSuites.get(i), i, junitClassName);
    }

    writeDriverFile(subSuites.size(), junitClassName);
  }

  private static void writeSubSuite(
      List<Sequence> sequencesForOneFile, int i, String junitClassName) {
    PrintStream out = createTextOutputStream(junitClassName + i + ".java");
    try {
      out.println("public class " + junitClassName + i + " {");

      int testCounter = 0;
      for (Sequence fault : sequencesForOneFile) {
        out.println("public static void testclasses" + testCounter++ + "() {");
        out.println("try {");
        out.println(fault.toCodeString());
        out.println("} catch (Throwable t) { /* do nothing */ }");
        out.println(junitClassName + ".numTests++;");
        out.println("}");
        out.println();
      }

      out.println("public static void run() {");
      for (int ti = 0; ti < testCounter; ti++) {
        out.println("testclasses" + ti + "();");
      }
      out.println("}");
      out.println("}");
    } finally {
      if (out != null) out.close();
    }
  }

  private static void writeDriverFile(int numSubSuites, String junitClassName) {
    PrintStream out = createTextOutputStream(junitClassName + ".java");
    try {
      out.println("public class " + junitClassName + " {");
      out.println("  public static int numTests = 0;");
      out.println("  public static void main(String[] args) {");
      out.println("    long startTime = System.currentTimeMillis();");
      for (int i = 0; i < numSubSuites; i++) out.println("    " + junitClassName + i + ".run();");
      out.println("    long stopTime = System.currentTimeMillis();");
      out.println("    System.out.println(\"Executed \" + numTests + \" tests.\");");
      out.println(
          "    System.out.println(\"Time spent executing tests: \" + (stopTime-startTime) + \"ms.\");");
      out.println("  }");
      out.println("");
      out.println("}");
    } finally {
      if (out != null) out.close();
    }
  }

  private static PrintStream createTextOutputStream(String fileName) {
    try {
      return new PrintStream(new File(fileName));
    } catch (FileNotFoundException e) {
      Log.out.println("Exception thrown while creating text print stream:" + fileName);
      e.printStackTrace();
      System.exit(1);
      throw new Error("This can't happen");
    }
  }
}


text:
public class Main {

	public static void main(String[] args) throws InterruptedException {
		MainFrame frame = new MainFrame();
		frame.setVisible(true);
	}

}


text:
FirmwareUpdatr
==============

Printrbot Firmware Updater for Mac OS X

**NOTE:** If you just want the pre-built app, get it from http://www.printrbottalk.com/wiki/index.php?title=User:PxT

Build Requirements:
  * Platypus: http://sveinbjorn.org/platypus

  Install the GUI app and also the command-line tool (from within the app's Preferences window)

  * cocoaDialog: http://mstratman.github.io/cocoadialog/

  This must be installed in /Applications, a copy will be bundled into the finished app

  * dfu-programmer: http://dfu-programmer.sourceforge.net

  A copy is provided along with this script and will be bundled into the finished app

  * Xcode command line tools (make, gcc, etc.):  https://developer.apple.com/xcode/

Build Process:
  * Build the dfu-programmer binary and libraries:

     cd dfu ; ./build.sh
  * Edit the build-firmware-app.sh script if necessary to adjust the version number and path to your dfu files
  * ./build-firmware-app.sh

  The app will be built and written into the current directory


text:
#region Copyright

#endregion

using System;
using System.Collections.Generic;
using System.Windows.Controls;
using Dynamo.Controls;
using Dynamo.Models;
using Dynamo.Wpf;
using ProtoCore.AST.AssociativeAST;
using Kodestruct.Common.CalculationLogger;
using Kodestruct.Dynamo.Common;
using Dynamo.Nodes;
using Dynamo.Graph.Nodes;
using System.Xml;
using Dynamo.Graph;

namespace Kodestruct.Wood.NDS.General
{

    /// <summary>
    ///Service moisture condition
    /// </summary>

    [NodeName("Service moisture condition")]
    [NodeCategory("Kodestruct.Wood.NDS.General")]
    [NodeDescription("Service moisture condition")]
    [IsDesignScriptCompatible]
    public class ServiceMoistureConditionSelection : UiNodeBase
    {

        public ServiceMoistureConditionSelection()
        {

            //OutPortData.Add(new PortData("ReportEntry", "Calculation log entries (for reporting)"));
            OutPortData.Add(new PortData("ServiceMoistureCondition", "Identifies the type of service moisture conditions for wet service factor"));
            RegisterAllPorts();
            SetDefaultParameters();
            //PropertyChanged += NodePropertyChanged;
        }

        private void SetDefaultParameters()
        {
            ServiceMoistureCondition = "Dry";
            //ReportEntry="";

        }

        /// <summary>
        ///     Gets the type of this class, to be used in base class for reflection
        /// </summary>
        protected override Type GetModelType()
        {
            return GetType();
        }

        #region Properties

        #region InputProperties

	    #endregion

        #region OutputProperties

		#region ServiceMoistureConditionProperty

		/// <summary>
		/// ServiceMoistureCondition property
		/// </summary>
		/// <value>Identifies the type of service moisture conditions for wet service factor</value>
		public string _ServiceMoistureCondition;

		public string ServiceMoistureCondition
		{
		    get { return _ServiceMoistureCondition; }
		    set
		    {
		        _ServiceMoistureCondition = value;
		        RaisePropertyChanged("ServiceMoistureCondition");
		        OnNodeModified();
		    }
		}
		#endregion

        #region ReportEntryProperty

        /// <summary>
        /// log property
        /// </summary>
        /// <value>Calculation entries that can be converted into a report.</value>

        public string reportEntry;

        public string ReportEntry
        {
            get { return reportEntry; }
            set
            {
                reportEntry = value;
                RaisePropertyChanged("ReportEntry");
                OnNodeModified();
            }
        }

        #endregion

        #endregion
        #endregion

        #region Serialization

        /// <summary>
        ///Saves property values to be retained when opening the node
        /// </summary>
        protected override void SerializeCore(XmlElement nodeElement, SaveContext context)
        {
            base.SerializeCore(nodeElement, context);
            nodeElement.SetAttribute("ServiceMoistureCondition", ServiceMoistureCondition);
        }

        /// <summary>
        ///Retrieved property values when opening the node
        /// </summary>
        protected override void DeserializeCore(XmlElement nodeElement, SaveContext context)
        {
            base.DeserializeCore(nodeElement, context);
            var attrib = nodeElement.Attributes["ServiceMoistureCondition"];
            if (attrib == null)
                return;

            ServiceMoistureCondition = attrib.Value;
            //SetComponentDescription();

        }

        #endregion

        /// <summary>
        ///Customization of WPF view in Dynamo UI
        /// </summary>
        public class ServiceMoistureConditionTypeSelectionViewCustomization : UiNodeBaseViewCustomization,
            INodeViewCustomization<ServiceMoistureConditionSelection>
        {
            public void CustomizeView(ServiceMoistureConditionSelection model, NodeView nodeView)
            {
                base.CustomizeView(model, nodeView);

                ServiceMoistureConditionTypeSelectionView control = new ServiceMoistureConditionTypeSelectionView();
                control.DataContext = model;

                nodeView.inputGrid.Children.Add(control);
                base.CustomizeView(model, nodeView);
            }

        }
    }
}


text:
package org.apache.sshd.util.test;

import org.slf4j.LoggerFactory;

import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Logger;

/**
 * @author Apache MINA SSHD Project
 */
public class JSchLogger implements Logger {
    private final org.slf4j.Logger log = LoggerFactory.getLogger(JSch.class);

    public JSchLogger() {
        super();
    }

    @Override
    public boolean isEnabled(int level) {
        switch (level) {
            case INFO:  // INFO is too "chatty" so we map it to debug
            case DEBUG:
                return log.isDebugEnabled();
            case WARN:
                return log.isWarnEnabled();
            case ERROR:
                return log.isErrorEnabled();
            case FATAL:
                return log.isErrorEnabled();
            default:
                return false;
        }
    }

    @Override
    public void log(int level, String message) {
        switch (level) {
            case INFO:  // INFO is too "chatty" so we map it to debug
            case DEBUG:
                log.debug(message);
                break;
            case WARN:
                log.warn(message);
                break;
            case ERROR:
            case FATAL:
                log.error(message);
                break;
            default:
                log.error("[LEVEL=" + level + "]: " + message);
        }
    }

    public static void init() {
        JSch.setLogger(new JSchLogger());
    }
}


text:
<?php

namespace Cerad\Bundle\LevelBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class CeradLevelBundle extends Bundle
{
}


text:
import { Component } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { UserService } from '../shared/services/user.service';
import { AppService } from '../shared/services/app.service';

declare var toast: any;

@Component({
    selector: 'respond-reset',
    templateUrl: 'reset.component.html',
    providers: [UserService, AppService]
})

export class ResetComponent {

  data;
  id;
  token;
  errorMessage;
  logoUrl;

  constructor (private _userService: UserService, private _appService: AppService, private _route: ActivatedRoute) {}

  ngOnInit() {
      this.logoUrl = '';

      this._route.params.subscribe(params => {
        this.id = params['id'];
        this.token = params['token'];
      });

      // retrieve settings
      this.settings();
  }

  /**
   * Get settings
   */
  settings() {

    // list themes in the app
    this._appService.retrieveSettings()
                     .subscribe(
                       data => {
                         this.logoUrl = data.logoUrl;
                       },
                       error =>  { this.failure(<any>error); }
                      );

  }

  /**
   * Reset the password
   */
  reset(event, password, retype){

      event.preventDefault();

      if(password !== retype) {
        alert('Password mismatch');
      }
      else {
        this._userService.reset(this.id, this.token, password)
                     .subscribe(
                       () => { alert('success'); },
                       error =>  { this.failure(<any>error); }
                      );
      }

  }

  /**
   * handles error
   */
  failure (obj) {

    toast.show('failure');

  }

}


text:
<Model File="roland2-site.tvm"/>
<Info Author="Marcelo Caceres" Notes="Roland2 SAM site model (rotate the roland group for animation?)"/>
<Animation Object="roland" Type="Sensor" SensorIndex="0" AxisX="0" AxisY="0" AxisZ="1" AngleRate="0.2"/>
<Launcher X="0.0" Y="3.0" Z="0" Az="0" El="45"/>


text:
layout: post
status: publish
published: true
title: !binary |-
  UHJlbWnDqHJlIHBob3RvIGRlICJTdXIgbGEgcGlzdGUgZHUgTWFyc3VwaWxh
  bWki
author: mick
author_login: mick
author_email: mickael@flochlay.com
wordpress_id: 843
wordpress_url: http://morningcoffee.mickaelflochlay.com/?p=843
date: 2011-10-02 22:23:37.000000000 +02:00
categories:
- !binary |-
  Q2luw6ltYQ==
tags:
- Alain Chabat
- Jamel Debbouze
- Marsupilami
comments: []
---

En attendant le teaser qui ne devrait pas tarder, voici la première photo du prochain film d'Alain Chabat, "Sur la piste du Marsupilami". La sortie est fixée le 4 avril 2012.

via      LES NULS > LE BLOG: PREMIERE PHOTO POUR LE MARSUPILAMI D'ALAIN CHABAT.


text:
<?php

namespace spec\carlosV2\Can\Exception;

use PhpSpec\ObjectBehavior;

class AsserterNotFoundExceptionSpec extends ObjectBehavior
{
    function it_is_an_Exception()
    {
        $this->shouldHaveType('\Exception');
    }
}


text:
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.compositor.bottombar;

import org.chromium.chrome.browser.compositor.bottombar.OverlayPanel.StateChangeReason;

/**
 * Wrapper for OverlayPanelManager to record and test calls to the show and hide functions. This
 * class should contain the absolute count for the number of times a panel is shown or hidden
 * as it is the only one that controls panel display.
 */
public class OverlayPanelManagerWrapper extends OverlayPanelManager {
    private int mRequestPanelShowCount;
    private int mPanelHideCount;

    @Override
    public void requestPanelShow(OverlayPanel panel, StateChangeReason reason) {
        mRequestPanelShowCount++;
        super.requestPanelShow(panel, reason);
    }

    @Override
    public void notifyPanelClosed(OverlayPanel panel, StateChangeReason reason) {
        mPanelHideCount++;
        super.notifyPanelClosed(panel, reason);
    }

    public int getRequestPanelShowCount() {
        return mRequestPanelShowCount;
    }

    public int getPanelHideCount() {
        return mPanelHideCount;
    }
}


text: Tests different types of search-and-replace in SourceFrame


text:
import Collection from './Collection';
import DatasetModel from '../models/DatasetModel';

const DatasetCollection = Collection.extend({
    resourceName: 'dataset',
    model: DatasetModel,
    sortField: '_id'
});

export default DatasetCollection;


text:
using System;
using System.Linq;
using LinqToTwitter;
using LinqToTwitterPcl.Tests.Common;
using LitJson;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace LinqToTwitterPcl.Tests.GeoTests
{
    [TestClass]
    public class GeometryTests
    {
        public GeometryTests()
        {
            TestCulture.SetCulture();
        }

        [TestMethod]
        public void Geometry_Ctor_Parses_JsonData()
        {
            var geometryJson = JsonMapper.ToObject(GeometryJson);

            var geometry = new Geometry(geometryJson);

            Assert.AreEqual("Polygon", geometry.Type);
            Assert.IsNotNull(geometry.Coordinates);
            Assert.AreEqual(4, geometry.Coordinates.Count);
            Coordinate coord = geometry.Coordinates.First();
            Assert.AreEqual(-122.51368188, coord.Longitude);
            Assert.AreEqual(37.70813196, coord.Latitude);
        }

        [TestMethod]
        public void Geometry_Ctor_Returns_On_Null_JsonData()
        {
            var geometry = new Geometry(null);

            Assert.AreEqual(null, geometry.Type);
        }

        const string GeometryJson = @"{
                     ""type"":""Polygon"",
                     ""coordinates"":[
                        [
                           [
                              -122.51368188,
                              37.70813196
                           ],
                           [
                              -122.35845384,
                              37.70813196
                           ],
                           [
                              -122.35845384,
                              37.83245301
                           ],
                           [
                              -122.51368188,
                              37.83245301
                           ]
                        ]
                     ]
                  }";

    }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.9.4"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>OR-Tools: Class Members - Variables</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

<link href="navtree.css" rel="stylesheet" type="text/css"/>

<link href="search/search.css" rel="stylesheet" type="text/css"/>

<link href="doxygen.css" rel="stylesheet" type="text/css" />
<link href="styleSheet.tmp.css" rel="stylesheet" type="text/css"/>

OR-Tools
    9.4

- r -

radius : LocalizedLagrangianBounds

random_seed : DefaultPhaseParameters, FlatzincSatParameters, SolveParameters

range : CallbackRangeConstraint, GScipIndicatorRangeConstraint

rank : SharedSolutionRepository< ValueType >::Solution

reason : Termination, TerminationReasonAndPointType

reasons : PbConstraintsEnqueueHelper

recycle_solutions_ : SolutionCollector

reduced_costs : DualRay, DualSolution, SolverResult

reduced_costs_filter : ModelSolveParameters

reduced_domain_vars : RINSNeighborhood

ref : VarValue

relative_gap_tolerance : SolveParameters

relative_l2_dual_residual : RelativeConvergenceInformation

relative_l2_primal_residual : RelativeConvergenceInformation

relative_l_inf_dual_residual : RelativeConvergenceInformation

relative_l_inf_primal_residual : RelativeConvergenceInformation

relative_optimality_gap : RelativeConvergenceInformation

removable : GScipConstraintOptions, GScipVariableOptions, ScipCallbackConstraintOptions

removed_nodes_ : FilteredHeuristicLocalSearchOperator

representation_clean_ : EbertGraphBase< NodeIndexType, ArcIndexType, DerivedGraph >

representative : AffineRelation::Relation

required_resource_group_indices : RoutingModel::VehicleClass

residual_arc_capacity_ : GenericMaxFlow< Graph >

restart_policies : SearchHeuristics

result_status_ : MPSolverInterface

resultant : GScipLogicalConstraintData

rev_bool_value_ : Trail

rev_bools_ : Trail

rev_boolvar_list_ : Trail

rev_double_memory_ : Trail

rev_doubles_ : Trail

rev_int64_memory_ : Trail

rev_int64s_ : Trail

rev_int_memory_ : Trail

rev_ints_ : Trail

rev_memory_ : Trail

rev_memory_array_ : Trail

rev_object_array_memory_ : Trail

rev_object_memory_ : Trail

rev_ptrs_ : Trail

rev_uint64s_ : Trail

reversible_action : StateInfo

rhs : VariablesEquality

rhs_parity : ZeroHalfCutHelper::CombinationOfRows

right_value : LiteralValueValue

root : BlossomGraph::Node

row : MatrixEntry

row_scaling_vec : ScalingVectors

rows_ : CompactSparseMatrix

run_all_heuristics : DefaultPhaseParameters

runner : SCIP_ConshdlrData

runtime : CallbackData

Generated by

     1.9.4


text:
/**********************************************************\

  Auto-generated npfs.h

  This file contains the auto-generated main plugin object
  implementation for the npfs project

\**********************************************************/
#ifndef H_npfsPLUGIN
#define H_npfsPLUGIN

#include "PluginWindow.h"
#include "PluginEvents/MouseEvents.h"
#include "PluginEvents/AttachedEvent.h"

#include "PluginCore.h"

FB_FORWARD_PTR(npfs)
class npfs : public FB::PluginCore
{
public:
    static void StaticInitialize();
    static void StaticDeinitialize();

public:
    npfs();
    virtual ~npfs();

public:
    void onPluginReady();
    void shutdown();
    virtual FB::JSAPIPtr createJSAPI();
    // If you want your plugin to always be windowless, set this to true
    // If you want your plugin to be optionally windowless based on the
    // value of the "windowless" param tag, remove this method or return
    // FB::PluginCore::isWindowless()
    virtual bool isWindowless() { return false; }

    BEGIN_PLUGIN_EVENT_MAP()
        EVENTTYPE_CASE(FB::MouseDownEvent, onMouseDown, FB::PluginWindow)
        EVENTTYPE_CASE(FB::MouseUpEvent, onMouseUp, FB::PluginWindow)
        EVENTTYPE_CASE(FB::MouseMoveEvent, onMouseMove, FB::PluginWindow)
        EVENTTYPE_CASE(FB::MouseMoveEvent, onMouseMove, FB::PluginWindow)
        EVENTTYPE_CASE(FB::AttachedEvent, onWindowAttached, FB::PluginWindow)
        EVENTTYPE_CASE(FB::DetachedEvent, onWindowDetached, FB::PluginWindow)
    END_PLUGIN_EVENT_MAP()

    /** BEGIN EVENTDEF -- DON'T CHANGE THIS LINE **/
    virtual bool onMouseDown(FB::MouseDownEvent *evt, FB::PluginWindow *);
    virtual bool onMouseUp(FB::MouseUpEvent *evt, FB::PluginWindow *);
    virtual bool onMouseMove(FB::MouseMoveEvent *evt, FB::PluginWindow *);
    virtual bool onWindowAttached(FB::AttachedEvent *evt, FB::PluginWindow *);
    virtual bool onWindowDetached(FB::DetachedEvent *evt, FB::PluginWindow *);
    /** END EVENTDEF -- DON'T CHANGE THIS LINE **/
};

#endif


text:
#include <gtest/gtest.h>
#include <iostream>
#include <maze/orthogonal/maze.hpp>
#include <maze/orthogonal/query.hpp>

using namespace maze::orthogonal;
using namespace maze::utility;

namespace {

class OrthogonalQueryTest : public ::testing::Test {
 protected:

  OrthogonalQueryTest() {
  }

  virtual ~OrthogonalQueryTest() {
  }

  virtual void SetUp() {
  }

  virtual void TearDown() {
  }
};

TEST_F(OrthogonalQueryTest, HasAdjacentRoom) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::North, middle_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::South, middle_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::East, middle_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::West, middle_room));

	Maze<>::RoomProperties& top_left_room = maze.roomProperties(0, 0);
	EXPECT_EQ(false, hasAdjacentRoom(maze, Direction::North, top_left_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::South, top_left_room));
	EXPECT_EQ(false, hasAdjacentRoom(maze, Direction::East, top_left_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::West, top_left_room));

	Maze<>::RoomProperties& bottom_right_room = maze.roomProperties(2, 2);
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::North, bottom_right_room));
	EXPECT_EQ(false, hasAdjacentRoom(maze, Direction::South, bottom_right_room));
	EXPECT_EQ(true, hasAdjacentRoom(maze, Direction::East, bottom_right_room));
	EXPECT_EQ(false, hasAdjacentRoom(maze, Direction::West, bottom_right_room));
}

TEST_F(OrthogonalQueryTest, GetAdjacentRoom) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	if(hasAdjacentRoom(maze, Direction::North, middle_room))
	{
		Maze<>::RoomProperties& adjacent_room = adjacentRoom(maze, Direction::North, middle_room);
		EXPECT_EQ(middle_room.row-1, adjacent_room.row);
		EXPECT_EQ(middle_room.column, adjacent_room.column);
	}
	else
	{
		FAIL() << "no adjacent room";
	}
}

TEST_F(OrthogonalQueryTest, GetAdjacentRoomConstCorrectness) {
	const Maze<> maze(3,3);

	const Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	if(hasAdjacentRoom(maze, Direction::North, middle_room))
	{
		const Maze<>::RoomProperties& adjacent_room = adjacentRoom(maze, Direction::North, middle_room);
		EXPECT_EQ(middle_room.row-1, adjacent_room.row);
		EXPECT_EQ(middle_room.column, adjacent_room.column);
	}
	else
	{
		FAIL() << "no adjacent room";
	}
}

TEST_F(OrthogonalQueryTest, AdjacentRoomQuerySuccess) {
	const Maze<> maze(3,3);

	const Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);

	Maze<>::RoomQuery query = adjacentRoomQuery(maze, Direction::North, middle_room);

	if(query.second)
	{
		const Maze<>::RoomProperties& adjacent_room = maze.roomProperties(query.first);
		EXPECT_EQ(middle_room.row-1, adjacent_room.row);
		EXPECT_EQ(middle_room.column, adjacent_room.column);
	}
	else
	{
		FAIL() << "no adjacent room";
	}
}

TEST_F(OrthogonalQueryTest, AdjacentRoomQueryFail) {
	const Maze<> maze(3,3);

	const Maze<>::RoomProperties& top_right_room = maze.roomProperties(0, 2);

	Maze<>::RoomQuery query = adjacentRoomQuery(maze, Direction::North, top_right_room);

	EXPECT_EQ(false, query.second);
}

TEST_F(OrthogonalQueryTest, GetInvalidAdjacentRoomThrowsInvalidPositionException) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& bottom_right_room = maze.roomProperties(2, 2);

	try{
		Maze<>::RoomProperties& adjacent_room = adjacentRoom(maze, Direction::West, bottom_right_room);
		FAIL() << "adjacentRoom() did not throw exception as expected";
	}
	catch(InvalidPositionException&){
		SUCCEED();
	}
}

TEST_F(OrthogonalQueryTest, ConnectedToAdjacentRoom) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	Maze<>::RoomProperties& top_middle_room = maze.roomProperties(0, 1);

	maze.addCorridor(middle_room.id, top_middle_room.id);

	EXPECT_EQ(true, connectedToAdjacentRoom(maze, Direction::North, middle_room));

	// direction of corridor matters (S->N is not the same as N->S)
	EXPECT_EQ(false, connectedToAdjacentRoom(maze, Direction::South, top_middle_room));
}

TEST_F(OrthogonalQueryTest, NotConnectedToAdjacentRoomNoCorridorsExist) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);

	EXPECT_EQ(false, connectedToAdjacentRoom(maze, Direction::North, middle_room));
}

TEST_F(OrthogonalQueryTest, NotConnectedToAdjacentRoomCorridorInWrongDirection) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	Maze<>::RoomProperties& top_middle_room = maze.roomProperties(0, 1);

	// corridor:= middle_room -> top_middle_room
	maze.addCorridor(middle_room.id, top_middle_room.id);

	// check corridor:= top_middle_room -> middle_room (opposite direction)
	EXPECT_EQ(false, connectedToAdjacentRoom(maze, Direction::South, top_middle_room));
}

TEST_F(OrthogonalQueryTest, NotConnectedToAdjacentRoomInvalidAdjacentRoom) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& bottom_right_room = maze.roomProperties(2, 2);

	// No corridors exist
	EXPECT_EQ(false, connectedToAdjacentRoom(maze, Direction::South, bottom_right_room));
}

TEST_F(OrthogonalQueryTest, ConnectedToAdjacentRoomUndirected) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	Maze<>::RoomProperties& top_middle_room = maze.roomProperties(0, 1);

	maze.addCorridor(middle_room.id, top_middle_room.id);

	EXPECT_EQ(true, connectedToAdjacentRoomUndirected(maze, Direction::North, middle_room));

	// direction of corridor does not matter
	EXPECT_EQ(true, connectedToAdjacentRoomUndirected(maze, Direction::South, top_middle_room));
}

TEST_F(OrthogonalQueryTest, NotConnectedToAdjacentRoomUndirectedNoCorridorsExist) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);

	EXPECT_EQ(false, connectedToAdjacentRoomUndirected(maze, Direction::North, middle_room));
}

TEST_F(OrthogonalQueryTest, NotConnectedToAdjacentRoomUndirectedInvalidAdjacentRoom) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& bottom_right_room = maze.roomProperties(2, 2);

	// No corridors exist
	EXPECT_EQ(false, connectedToAdjacentRoomUndirected(maze, Direction::South, bottom_right_room));
}

TEST_F(OrthogonalQueryTest, RoomWithNoCorridorsIsDeadEnd) {
	Maze<> maze(3,3);
	EXPECT_EQ(true, isDeadEnd(maze, 0));
}

TEST_F(OrthogonalQueryTest, RoomWithOneCorridorIsDeadEnd) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	Maze<>::RoomProperties& top_middle_room = maze.roomProperties(0, 1);

	maze.addCorridorInBothDirections(middle_room.id, top_middle_room.id);

	EXPECT_EQ(true, isDeadEnd(maze, middle_room.id));
	EXPECT_EQ(true, isDeadEnd(maze, top_middle_room.id));
}

TEST_F(OrthogonalQueryTest, RoomWithMoreThanOneCorridorIsNotDeadEnd) {
	Maze<> maze(3,3);

	Maze<>::RoomProperties& top_middle_room = maze.roomProperties(0, 1);
	Maze<>::RoomProperties& middle_room = maze.roomProperties(1, 1);
	Maze<>::RoomProperties& bottom_middle_room = maze.roomProperties(2, 1);

	maze.addCorridorInBothDirections(middle_room.id, top_middle_room.id);
	maze.addCorridorInBothDirections(middle_room.id, bottom_middle_room.id);

	EXPECT_EQ(false, isDeadEnd(maze, middle_room.id));
}

}  // namespace