text:
SDLPredefinedLayout const SDLPredefinedLayoutDefault = @"DEFAULT";
SDLPredefinedLayout const SDLPredefinedLayoutMedia = @"MEDIA";
SDLPredefinedLayout const SDLPredefinedLayoutNonMedia = @"NON-MEDIA";
SDLPredefinedLayout const SDLPredefinedLayoutOnscreenPresets = @"ONSCREEN_PRESETS";
SDLPredefinedLayout const SDLPredefinedLayoutNavigationFullscreenMap = @"NAV_FULLSCREEN_MAP";
SDLPredefinedLayout const SDLPredefinedLayoutNavigationList = @"NAV_LIST";
SDLPredefinedLayout const SDLPredefinedLayoutNavigationKeyboard = @"NAV_KEYBOARD";
SDLPredefinedLayout const SDLPredefinedLayoutGraphicWithText = @"GRAPHIC_WITH_TEXT";
SDLPredefinedLayout const SDLPredefinedLayoutTextWithGraphic = @"TEXT_WITH_GRAPHIC";
SDLPredefinedLayout const SDLPredefinedLayoutTilesOnly = @"TILES_ONLY";
SDLPredefinedLayout const SDLPredefinedLayoutTextButtonsOnly = @"TEXTBUTTONS_ONLY";
SDLPredefinedLayout const SDLPredefinedLayoutGraphicWithTiles = @"GRAPHIC_WITH_TILES";
SDLPredefinedLayout const SDLPredefinedLayoutTilesWithGraphic = @"TILES_WITH_GRAPHIC";
SDLPredefinedLayout const SDLPredefinedLayoutGraphicWithTextAndSoftButtons = @"GRAPHIC_WITH_TEXT_AND_SOFTBUTTONS";
SDLPredefinedLayout const SDLPredefinedLayoutTextAndSoftButtonsWithGraphic = @"TEXT_AND_SOFTBUTTONS_WITH_GRAPHIC";
SDLPredefinedLayout const SDLPredefinedLayoutGraphicWithTextButtons = @"GRAPHIC_WITH_TEXTBUTTONS";
SDLPredefinedLayout const SDLPredefinedLayoutTextButtonsWithGraphic = @"TEXTBUTTONS_WITH_GRAPHIC";
SDLPredefinedLayout const SDLPredefinedLayoutLargeGraphicWithSoftButtons = @"LARGE_GRAPHIC_WITH_SOFTBUTTONS";
SDLPredefinedLayout const SDLPredefinedLayoutDoubleGraphicWithSoftButtons = @"DOUBLE_GRAPHIC_WITH_SOFTBUTTONS";
SDLPredefinedLayout const SDLPredefinedLayoutLargeGraphicOnly = @"LARGE_GRAPHIC_ONLY";


text:
/* Custom styles to override what is default
 provided by bootstrap
*/

body {font-family: Arial, Helvetica, sans-serif;}

/* Style the navigation bar */
.custom-navbar-1 {
	width: 100%;
	background-color: rgb(27, 26, 26);
	overflow: auto;
}

  /* Navbar links */
  .custom-navbar-1 a {
	float: left;
	text-align: center;
	padding: 12px;
	color: white;
	text-decoration: none;
	font-size: 17px;
  }

  /* Navbar links on mouse-over */
  .custom-navbar-1 a:hover {
	background-color: rgb(77, 77, 77);
  }

  /* Current/active navbar link */
.custom-active {
	background-color: rgb(91, 175, 94);
  }

  /* Style the search box inside the navigation bar */
.custom-navbar-1 input[type=text] {
	float: right;
	padding: 4px;
	border: none;
	margin-top: 8px;
	margin-right:86px;
	font-size: 17px;
  }

  /* Add responsiveness - will automatically display the navbar vertically instead of horizontally on screens less than 500 pixels */
  @media screen and (max-width: 500px) {
	.custom-navbar-1 a {
	  float: none;
	  display: block;
	}
  }

  /* Style the buttons that are used to open and close the accordion panel */
.custom-accordion-1 {
	background-color: #eee;
	color: #444;
	cursor: pointer;
	padding: 18px;
	width: 100%;
	text-align: left;
	border: none;
	outline: none;
	transition: 0.4s;
  }

  /* Add a background color to the button if it is clicked on (add the .active class with JS), and when you move the mouse over it (hover) */
  .active, .custom-accordion-1:hover {
	background-color: #ccc;
  }

  /* Style the accordion panel. Note: hidden by default */
  .custom-accordian-panel-1 {
	padding: 0 18px;
	background-color: white;
	display: none;
	overflow: hidden;
  }

redpajama_set_name: RedPajamaGithub


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

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical">

        <android.support.v7.widget.CardView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="10dp"
            android:longClickable="true"
            app:cardUseCompatPadding="true">

            <RelativeLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="vertical"
                android:padding="10dp">

                <TextView
                    android:id="@+id/label"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:text="@string/label" />

                <EditText
                    android:id="@+id/boys"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/label"
                    android:hint="@string/boys"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/girls"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/boys"
                    android:hint="@string/girls"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/corridor"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/girls"
                    android:hint="@string/corridor"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/campus"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/corridor"
                    android:hint="@string/campus"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/water"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/campus"
                    android:hint="@string/water"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/dishwash"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/water"
                    android:hint="@string/dishwash"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/classroom"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/dishwash"
                    android:hint="@string/classroom"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/storageroom"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/classroom"
                    android:hint="@string/storageroom"
                    android:inputType="number" />

                <EditText
                    android:id="@+id/emptydustbin"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_below="@id/storageroom"
                    android:hint="@string/emptydustbin"
                    android:inputType="number" />

            </RelativeLayout>
        </android.support.v7.widget.CardView>

        </LinearLayout>
    </ScrollView>
</LinearLayout>


text:
<project name="DeepThought" default="dist">
    <import file="../../asl-java-build.xml"/>
    <import file="../../asl-java-test.xml"/>
    <import file="../../asl-java-report.xml"/>
    <import file="../../asl-java-package.xml"/>
</project>


text:
require File.join(File.dirname(__FILE__), "test_helper")

class DescriptorTest < Test::Unit::TestCase
  include Google::Protobuf
  def test_build
    tutorial_proto = FileDescriptorProto.new
    tutorial_proto.package = 'Build::Tutorial'

    person_proto = DescriptorProto.new
    tutorial_proto.message_type << person_proto
    person_proto.name = 'Person'

    person_name_proto = FieldDescriptorProto.new
    person_proto.field << person_name_proto
    person_name_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
    person_name_proto.type = FieldDescriptorProto::Type::TYPE_STRING
    person_name_proto.name = 'name'
    person_name_proto.number = 1

    person_id_proto = FieldDescriptorProto.new
    person_proto.field << person_id_proto
    person_id_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
    person_id_proto.type = FieldDescriptorProto::Type::TYPE_INT32
    person_id_proto.name = 'id'
    person_id_proto.number = 2

    person_email_proto = FieldDescriptorProto.new
    person_proto.field << person_email_proto
    person_email_proto.label = FieldDescriptorProto::Label::LABEL_OPTIONAL
    person_email_proto.type = FieldDescriptorProto::Type::TYPE_STRING
    person_email_proto.name = 'email'
    person_email_proto.number = 3

    person_phone_type_proto = EnumDescriptorProto.new
    person_proto.enum_type << person_phone_type_proto
    person_phone_type_proto.name = 'PhoneType'

    person_phone_type_mobile_proto = EnumValueDescriptorProto.new
    person_phone_type_proto.value << person_phone_type_mobile_proto
    person_phone_type_mobile_proto.name = 'MOBILE'
    person_phone_type_mobile_proto.number = 0

    person_phone_type_home_proto = EnumValueDescriptorProto.new
    person_phone_type_proto.value << person_phone_type_home_proto
    person_phone_type_home_proto.name = 'HOME'
    person_phone_type_home_proto.number = 1

    person_phone_type_work_proto = EnumValueDescriptorProto.new
    person_phone_type_proto.value << person_phone_type_work_proto
    person_phone_type_work_proto.name = 'WORK'
    person_phone_type_work_proto.number = 2

    person_phone_number_proto = DescriptorProto.new
    person_proto.nested_type << person_phone_number_proto
    person_phone_number_proto.name = 'PhoneNumber'

    person_phone_number_number_proto = FieldDescriptorProto.new
    person_phone_number_proto.field << person_phone_number_number_proto
    person_phone_number_number_proto.label = FieldDescriptorProto::Label::LABEL_REQUIRED
    person_phone_number_number_proto.type = FieldDescriptorProto::Type::TYPE_STRING
    person_phone_number_number_proto.name = 'number'
    person_phone_number_number_proto.number = 1

    person_phone_number_type_proto = FieldDescriptorProto.new
    person_phone_number_proto.field << person_phone_number_type_proto
    person_phone_number_type_proto.label = FieldDescriptorProto::Label::LABEL_OPTIONAL
    person_phone_number_type_proto.type = FieldDescriptorProto::Type::TYPE_ENUM
    person_phone_number_type_proto.type_name = 'PhoneType'
    person_phone_number_type_proto.name = 'type'
    person_phone_number_type_proto.number = 2
    person_phone_number_type_proto.default_value = 'HOME'

    person_phone_phone_number_proto = FieldDescriptorProto.new
    person_proto.field << person_phone_phone_number_proto
    person_phone_phone_number_proto.label = FieldDescriptorProto::Label::LABEL_REPEATED
    person_phone_phone_number_proto.type = FieldDescriptorProto::Type::TYPE_MESSAGE
    person_phone_phone_number_proto.type_name = 'PhoneNumber'
    person_phone_phone_number_proto.name = 'phone'
    person_phone_phone_number_proto.number = 4

    address_book_proto = DescriptorProto.new
    tutorial_proto.message_type << address_book_proto
    address_book_proto.name = 'AddressBook'

    address_book_person_proto = FieldDescriptorProto.new
    address_book_proto.field << address_book_person_proto
    address_book_person_proto.label = FieldDescriptorProto::Label::LABEL_REPEATED
    address_book_person_proto.type = FieldDescriptorProto::Type::TYPE_MESSAGE
    address_book_person_proto.type_name = 'Person'
    address_book_person_proto.name = 'person'
    address_book_person_proto.number = 1

    Protobuf::Descriptor::DescriptorBuilder.build tutorial_proto

    assert_nothing_raised {Build::Tutorial::Person}
    assert_nothing_raised {Build::Tutorial::Person.new}
    assert_equal ['email', 'id', 'name', 'phone'],
      Build::Tutorial::Person.fields.map{|tag, field| field.name}.sort

    assert_nothing_raised {Build::Tutorial::Person::PhoneNumber}
    assert_nothing_raised {Build::Tutorial::Person::PhoneNumber.new}
    assert_equal ['number', 'type'],
      Build::Tutorial::Person::PhoneNumber.fields.map{|tag, field| field.name}.sort

    assert_nothing_raised {Build::Tutorial::Person::PhoneType}
    assert_equal 0, Build::Tutorial::Person::PhoneType::MOBILE
    assert_equal 1, Build::Tutorial::Person::PhoneType::HOME
    assert_equal 2, Build::Tutorial::Person::PhoneType::WORK

    assert_nothing_raised {Build::Tutorial::AddressBook}
  end
end


text:
"""
@Description : This tool helps to filter pindel v0.2.5a7 vcf through command line.
@Created :  07/17/2014
@Updated: 04/18/2017
@author : Ronak H Shah

"""
from __future__ import division
import argparse
import sys
import time
import os
import logging

logging.basicConfig(
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        datefmt='%m/%d/%Y %I:%M:%S %p',
        level=logging.DEBUG)
logger = logging.getLogger('filter_pindel')
try:
    import coloredlogs
    coloredlogs.install(level='DEBUG')
except ImportError:
    logger.warning("filter_pindel: coloredlogs is not installed, please install it if you wish to see color in logs on standard out.")
    pass
try:
    import vcf
    from vcf.parser import _Format as VcfFormat, field_counts as vcf_field_counts
except ImportError:
    logger.fatal("filter_pindel: pyvcf is not installed, please install pyvcf as it is required to run the mapping.")
    sys.exit(1)

def main():
    parser = argparse.ArgumentParser(
        prog='filter_pindel.py',
        description='Filter indels from the output of pindel v0.2.5a7',
        usage='%(prog)s [options]')
    parser.add_argument(
        "-v",
        "--verbose",
        action="store_true",
        dest="verbose",
        help="make lots of noise")
    parser.add_argument(
        "-ivcf",
        "--inputVcf",
        action="store",
        dest="inputVcf",
        required=True,
        type=str,
        metavar='SomeID.vcf',
        help="Input vcf freebayes file which needs to be filtered")
    parser.add_argument(
        "-tsn",
        "--tsampleName",
        action="store",
        dest="tsampleName",
        required=True,
        type=str,
        metavar='SomeName',
        help="Name of the tumor Sample")
    parser.add_argument(
        "-dp",
        "--totaldepth",
        action="store",
        dest="dp",
        required=False,
        type=int,
        default=0,
        metavar='0',
        help="Tumor total depth threshold")
    parser.add_argument(
        "-ad",
        "--alleledepth",
        action="store",
        dest="ad",
        required=False,
        type=int,
        default=5,
        metavar='5',
        help="Tumor allele depth threshold")
    parser.add_argument(
        "-tnr",
        "--tnRatio",
        action="store",
        dest="tnr",
        required=False,
        type=int,
        default=5,
        metavar='5',
        help="Tumor-Normal variant frequency ratio threshold ")
    parser.add_argument(
        "-vf",
        "--variantfrequency",
        action="store",
        dest="vf",
        required=False,
        type=float,
        default=0.01,
        metavar='0.01',
        help="Tumor variant frequency threshold ")
    parser.add_argument(
        "-o",
        "--outDir",
        action="store",
        dest="outdir",
        required=False,
        type=str,
        metavar='/somepath/output',
        help="Full Path to the output dir.")
    parser.add_argument(
        "-min",
        "--min_var_len",
        action="store",
        dest="min",
        required=False,
        default=0,
        type=int,
        metavar='0',
        help="Minimum length of the indels")
    parser.add_argument(
        "-max",
        "--max_var_len",
        action="store",
        dest="max",
        required=False,
        default=2000,
        type=int,
        metavar='500',
        help="Max length of the indels")
    parser.add_argument(
        "-hvcf",
        "--hotspotVcf",
        action="store",
        dest="hotspotVcf",
        required=False,
        type=str,
        metavar='hostpot.vcf',
        help="Input bgzip / tabix indexed hotspot vcf file to used for filtering")

    args = parser.parse_args()
    if(args.verbose):
        logger.info("Started the run for doing standard filter.")
    (stdfilterVCF) = RunStdFilter(args)
    if(args.verbose):
        logger.info("Finished the run for doing standard filter.")

def RunStdFilter(args):
    vcf_out = os.path.basename(args.inputVcf)
    vcf_out = os.path.splitext(vcf_out)[0]
    txt_out = vcf_out
    if(args.outdir):
        vcf_out = os.path.join(args.outdir,vcf_out + "_STDfilter.vcf")
        txt_out = os.path.join(args.outdir,txt_out + "_STDfilter.txt")
    else:
        vcf_out = vcf_out + "_STDfilter.vcf"
        txt_out = txt_out + "_STDfilter.txt"
    vcf_reader = vcf.Reader(open(args.inputVcf, 'r'))
    del vcf_reader.infos['END']
    vcf_reader.formats['DP'] = VcfFormat('DP', '1', 'Integer', 'Total coverage at the site')
    vcf_writer = vcf.Writer(open(vcf_out, 'w'), vcf_reader)
    txt_fh = open(txt_out, "wb")
    allsamples = vcf_reader.samples
    if(len(allsamples) == 2):
        sample1 = allsamples[0]
        sample2 = allsamples[1]
    else:
        if(args.verbose):
            logger.critical("The VCF does not have two sample columns.Please input a proper vcf with Tumor/Normal columns")
        sys.exit(1)
    if(sample1 == args.tsampleName):
        nsampleName = sample2
    else:
        nsampleName = sample1
    for record in vcf_reader:
        tcall = record.genotype(args.tsampleName)
        recordType = record.INFO['SVTYPE']
        recordLen = abs(int(record.INFO['SVLEN']))
        record.INFO.pop('END',0)
        # print tcall, "recordType: ",recordType, "recordLen: ", recordLen

        if(tcall['AD'] is not None):
            trd, tad = tcall['AD']
        else:
            trd = 0
            tad = 0
        tdp = trd + tad
        if(tdp != 0):
            tvf = int(tad) / float(tdp)
        else:
            tvf = 0
        # print "Tdata: ",trd,tad
        ncall = record.genotype(nsampleName)
        if(ncall):
            if(ncall['AD'] is not None):
                nrd, nad = ncall['AD']
            else:
                nrd = 0
                nad = 0
            ndp = nrd + nad
            if(ndp != 0):
                nvf = nad / ndp
            else:
                nvf = 0
            # print "Ndata: ",trd,tad
            nvfRF = int(args.tnr) * nvf

            # print recordLen, args.min, args.max
        if(args.hotspotVcf):
            hotspotFlag = checkHotspot(args.hotspotVcf, record.CHROM, record.POS)
        else:
            hotspotFlag = False
        if((recordLen >= int(args.min)) and (recordLen <= int(args.max))):
            if(tvf > nvfRF):
                if((tdp >= int(args.dp)) & (tad >= int(args.ad)) & (tvf >= float(args.vf))):
                    if(recordType != "RPL"):
                        # print args.tsampleName , "\t" , record.CHROM , "\t" , str(record.POS) ,
                        # "\t" , str(record.REF) , "\t" + str(record.ALT[0]) , "\t" , "." + "\n"
                        vcf_writer.write_record(record)
                        txt_fh.write(
                            args.tsampleName + "\t" + record.CHROM + "\t" + str(record.POS) + "\t" +
                            str(record.REF) + "\t" + str(record.ALT[0]) + "\t" + "." + "\n")
            else:
                if(hotspotFlag):
                    if((tdp >= int(args.dp)) & (tad >= int(args.ad)) & (tvf >= float(args.vf))):
                        if(recordType != "RPL"):
                            # print args.tsampleName , "\t" , record.CHROM , "\t" , str(record.POS)
                            # , "\t" , str(record.REF) , "\t" + str(record.ALT[0]) , "\t" , "." +
                            # "\n"
                            vcf_writer.write_record(record)
                            txt_fh.write(args.tsampleName + "\t" + record.CHROM + "\t" +
                                         str(record.POS) + "\t" + str(record.REF) + "\t" +
                                         str(record.ALT[0]) + "\t" + "." + "\n")

    txt_fh.close()
    return(vcf_out)

def checkHotspot(hotspotVcf, chromosome, start):
    hotspotFlag = False
    hotspot_vcf_reader = vcf.Reader(open(hotspotVcf, 'r'))
    try:
        record = hotspot_vcf_reader.fetch(str(chromosome), start)
    except ValueError:
        logger.info("filter_pindel: Region not present in vcf, %s:%s", str(chromosome), start)
        record = None

    if(record is None):
        hotspotFlag = False
    else:
        hotspotFlag = True
    return(hotspotFlag)

if __name__ == "__main__":
    start_time = time.time()
    main()
    end_time = time.time()
    totaltime = end_time - start_time
    logging.info("filter_pindel: Elapsed time was %g seconds", totaltime)
    sys.exit(0)


text:
<?xml version="1.0" encoding="UTF-8"?>
<FindBugsFilter>
  <!-- Tests -->
  <Match>
    <Class name="~.*Test(\$[^\$]+)*"/>
  </Match>
  <!-- Noise -->
  <Match>
    <Bug code="Co,SF"
         category="I18N"
         pattern="REC_CATCH_EXCEPTION,UWF_FIELD_NOT_INITIALIZED_IN_CONSTRUCTOR,DB_DUPLICATE_SWITCH_CLAUSES,VO_VOLATILE_REFERENCE_TO_ARRAY" />
  </Match>
  <!-- Known false positives -->
  <Match>
    <Class name="~.*Encapsulated"/>
    <Method name="compareTo"/>
    <Bug pattern="EQ_COMPARETO_USE_OBJECT_EQUALS"/>
  </Match>
</FindBugsFilter>


text:
require 'open-uri'
require 'nokogiri'
require 'pry'

require_relative '../lib/pokedex/cli'
require_relative '../lib/pokedex/scraper'
require_relative '../lib/pokedex/pokemon'


text:
'use strict';
let Colleges = require('../CollegeManager.js');
let Logger = require('fhda-pubsub-logging')('test-suite');
let OrientationJob = require('../scheduled-jobs/deanza/SyncOrientationResults');

describe('De Anza College - Online Orientation Support', function() {

    // Override default test timeout
    this.timeout(30000);

    let college = Colleges['deanza'];

    it('Can process enrollment records from the online orientation course', async function() {
        // Run the orientation records processing job
        await OrientationJob.bind(college)();
    });

});


text:
var gulp = require('gulp');
var config = require('gulp-oc-config');
var html2js = require('gulp-html2js');
var concat = require('gulp-concat');

gulp.task('build:templateCache', function() {
    return gulp.src(config.app_files.atpl)
        .pipe(html2js({
            base: 'src/app',
            outputModuleName: 'template-app',
            useStrict: true }))
        .pipe(concat('template-app.js'))
        .pipe(gulp.dest(config.build))
});

/* GRUNT TO COPY

html2js: {
    /!**
     * These are the templates from `src/app`.
     *!/
    app: {
        options: {
            base: 'src/app'
        },
        src: [ '<%= app_files.atpl %>' ],
        dest: '<%= build_dir %>/templates-app.js'
    }
},*/


text:
namespace Clix.QA.Selenium
{
	/// <summary>
	/// The CollectionControl interface.
	/// </summary>
	public interface ICollectionControl
	{
		/// <summary>
		/// The select by index.
		/// </summary>
		/// <param name="index">
		/// The index.
		/// </param>
		void SelectByIndex(int index);

		/// <summary>
		/// Selects element by its one-based index.
		/// </summary>
		/// <param name="position">
		/// The element position.
		/// </param>
		void SelectByPosition(int position);

		/// <summary>
		/// The select by text.
		/// </summary>
		/// <param name="text">
		/// The text.
		/// </param>
		void SelectByText(string text);
	}
}


text:
//******************************************************************************************************
//  IClient.cs - Gbtc
//
//  Copyright © 2012, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  07/26/2006 - Pinal C. Patel
//       Original version of source code generated.
//  09/06/2006 - J. Ritchie Carroll
//       Added ReceiveRawDataFunction delegate to allow bypass optimizations for high-speed data access.
//  05/01/2007 - Pinal C. Patel
//       Made WaitForConnection() functions that returns a boolean value indicating success or failure.
//  09/27/2007 - J. Ritchie Carroll
//       Added disconnect timeout overload.
//  09/29/2008 - J. Ritchie Carroll
//       Converted to C#.
//  11/07/2008 - Pinal C. Patel
//       Edited code comments.
//  07/08/2009 - J. Ritchie Carroll
//       Added WaitHandle return value from asynchronous connection.
//  08/05/2009 - Josh L. Patterson
//       Edited Comments.
//  09/14/2009 - Stephen C. Wills
//       Added new header and license agreement.
//  12/13/2012 - Starlynn Danyelle Gilliam
//       Modified Header.
//
//******************************************************************************************************

using System;
using System.Text;
using System.Threading;
using GSF.Units;

namespace GSF.Communication
{
    #region [ Enumerations ]

    /// <summary>
    /// Indicates the current state of the client.
    /// </summary>
    public enum ClientState
    {
        /// <summary>
        /// Client is establishing connection.
        /// </summary>
        Connecting,
        /// <summary>
        /// Client has established connection.
        /// </summary>
        Connected,
        /// <summary>
        /// Client connection is terminated.
        /// </summary>
        Disconnected
    }

    #endregion

    /// <summary>
    /// Defines a client involved in server-client communication.
    /// </summary>
    public interface IClient : ISupportLifecycle, IProvideStatus
    {
        #region [ Members ]

        // Events

        /// <summary>
        /// Occurs when client is attempting connection to the server.
        /// </summary>
        event EventHandler ConnectionAttempt;

        /// <summary>
        /// Occurs when client connection to the server is established.
        /// </summary>
        event EventHandler ConnectionEstablished;

        /// <summary>
        /// Occurs when client connection to the server is terminated.
        /// </summary>
        event EventHandler ConnectionTerminated;

        /// <summary>
        /// Occurs when an <see cref="Exception"/> is encountered during connection attempt to the server.
        /// </summary>
        event EventHandler<EventArgs<Exception>> ConnectionException;

        /// <summary>
        /// Occurs when the client begins sending data to the server.
        /// </summary>
        event EventHandler SendDataStart;

        /// <summary>
        /// Occurs when the client has successfully sent data to the server.
        /// </summary>
        event EventHandler SendDataComplete;

        /// <summary>
        /// Occurs when an <see cref="Exception"/> is encountered when sending data to the server.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T}.Argument"/> is the <see cref="Exception"/> encountered when sending data to the server.
        /// </remarks>
        event EventHandler<EventArgs<Exception>> SendDataException;

        /// <summary>
        /// Occurs when unprocessed data has been received from the server.
        /// </summary>
        /// <remarks>
        /// <para>
        /// This event can be used to receive a notification that server data has arrived. The <see cref="Read"/> method can then be used
        /// to copy data to an existing buffer. In many cases it will be optimal to use an existing buffer instead of subscribing to the
        /// <see cref="ReceiveDataComplete"/> event, however, the data that is available after calling the <see cref="Read"/> method
        /// will be the original unprocessed data received by the client, i.e., not optionally decrypted or decompressed data.
        /// </para>
        /// <para>
        /// <see cref="EventArgs{T}.Argument"/> is the number of bytes received in the buffer from the server.
        /// </para>
        /// </remarks>
        event EventHandler<EventArgs<int>> ReceiveData;

        /// <summary>
        /// Occurs when data received from the server has been processed and is ready for consumption.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T1,T2}.Argument1"/> is a new buffer containing post-processed data received from the server starting at index zero.<br/>
        /// <see cref="EventArgs{T1,T2}.Argument2"/> is the number of post-processed bytes received in the buffer from the server.
        /// </remarks>
        event EventHandler<EventArgs<byte[], int>> ReceiveDataComplete;

        /// <summary>
        /// Occurs when an <see cref="Exception"/> is encountered when receiving data from the server.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T}.Argument"/> is the <see cref="Exception"/> encountered when receiving data from the server.
        /// </remarks>
        event EventHandler<EventArgs<Exception>> ReceiveDataException;

        /// <summary>
        /// Occurs when an <see cref="Exception"/> is encountered in a user-defined function via an event dispatch.
        /// </summary>
        /// <remarks>
        /// <see cref="EventArgs{T}.Argument"/> is the <see cref="Exception"/> thrown by the user-defined function.
        /// </remarks>
        event EventHandler<EventArgs<Exception>> UnhandledUserException;

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the data required by the client to connect to the server.
        /// </summary>
        string ConnectionString
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the maximum number of times the client will attempt to connect to the server.
        /// </summary>
        int MaxConnectionAttempts
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the size of the buffer used by the client for receiving data from the server.
        /// </summary>
        int SendBufferSize
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the size of the buffer used by the client for receiving data from the server.
        /// </summary>
        int ReceiveBufferSize
        {
            get;
            set;
        }

        /// <summary>
        /// Gets or sets the <see cref="Encoding"/> to be used for the text sent to the server.
        /// </summary>
        Encoding TextEncoding
        {
            get;
            set;
        }

        /// <summary>
        /// Gets the server URI.
        /// </summary>
        string ServerUri
        {
            get;
        }

        /// <summary>
        /// Gets the current <see cref="ClientState"/>.
        /// </summary>
        ClientState CurrentState
        {
            get;
        }

        /// <summary>
        /// Gets the <see cref="TransportProtocol"/> used by the client for the transportation of data with the server.
        /// </summary>
        TransportProtocol TransportProtocol
        {
            get;
        }

        /// <summary>
        /// Gets the <see cref="Time"/> for which the client has been connected to the server.
        /// </summary>
        Time ConnectionTime
        {
            get;
        }

        /// <summary>
        /// Gets the <see cref="TransportStatistics"/> for the client connection.
        /// </summary>
        TransportStatistics Statistics
        {
            get;
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Connects client to the server synchronously.
        /// </summary>
        void Connect();

        /// <summary>
        /// Connects client to the server asynchronously.
        /// </summary>
        /// <returns><see cref="WaitHandle"/> for the asynchronous operation.</returns>
        WaitHandle ConnectAsync();

        /// <summary>
        /// Disconnects client from the server synchronously.
        /// </summary>
        void Disconnect();

        /// <summary>
        /// Sends data to the server synchronously.
        /// </summary>
        /// <param name="data">The buffer that contains the binary data to be sent.</param>
        /// <param name="offset">The zero-based position in the <paramref name="data"/> at which to begin sending data.</param>
        /// <param name="length">The number of bytes to be sent from <paramref name="data"/> starting at the <paramref name="offset"/>.</param>
        void Send(byte[] data, int offset, int length);

        /// <summary>
        /// Sends data to the server asynchronously.
        /// </summary>
        /// <param name="data">The buffer that contains the binary data to be sent.</param>
        /// <param name="offset">The zero-based position in the <paramref name="data"/> at which to begin sending data.</param>
        /// <param name="length">The number of bytes to be sent from <paramref name="data"/> starting at the <paramref name="offset"/>.</param>
        /// <returns><see cref="WaitHandle"/> for the asynchronous operation.</returns>
        WaitHandle SendAsync(byte[] data, int offset, int length);

        /// <summary>
        /// Reads a number of bytes from the current received data buffer and writes those bytes into a byte array at the specified offset.
        /// </summary>
        /// <param name="buffer">Destination buffer used to hold copied bytes.</param>
        /// <param name="startIndex">0-based starting index into destination <paramref name="buffer"/> to begin writing data.</param>
        /// <param name="length">The number of bytes to read from current received data buffer and write into <paramref name="buffer"/>.</param>
        /// <returns>The number of bytes read.</returns>
        /// <remarks>
        /// This function should only be called from within the <see cref="ReceiveData"/> event handler. Calling this method outside this event
        /// will have unexpected results.
        /// </remarks>
        int Read(byte[] buffer, int startIndex, int length);

        #endregion
    }
}


text:
// Copyright (c) 2015-2016 Yuya Ochiai
// Copyright (c) 2016-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.

// This file uses CommonJS.
/* eslint-disable import/no-commonjs */
'use strict';

const path = require('path');

const merge = require('webpack-merge');

const base = require('./webpack.config.base');

module.exports = merge(base, {
  entry: {
    index: './src/browser/index.jsx',
    settings: './src/browser/settings.jsx',
    updater: './src/browser/updater.jsx',
    'webview/mattermost': './src/browser/webview/mattermost.js',
  },
  output: {
    path: path.join(__dirname, 'src/browser'),
    publicPath: 'browser',
    filename: '[name]_bundle.js',
  },
  module: {
    rules: [{
      test: /\.(js|jsx)?$/,
      use: {
        loader: 'babel-loader',
      },
    }, {
      test: /\.css$/,
      use: [
        {loader: 'style-loader'},
        {loader: 'css-loader'},
      ],
    }, {
      test: /\.mp3$/,
      use: {
        loader: 'url-loader',
      },
    }, {
      test: /\.(svg|woff2)$/,
      use: [
        {
          loader: 'file-loader',
          options: {
            name: '[hash].[ext]',
            publicPath: './',
          },
        },
        {loader: 'image-webpack-loader'},
      ],
    }],
  },
  node: {
    __filename: true,
    __dirname: true,
  },
  target: 'electron-renderer',
  devServer: {
    contentBase: path.join(__dirname, 'src'),
    inline: true,
    publicPath: '/browser/',
  },
});

/* eslint-enable import/no-commonjs */


text:
import java.util.List;

class GenericsError {
  private static class ListHolder<T> {
    private List<T> <warning descr="Private field 'list' is never assigned">list</warning>;

    private void <warning descr="Private method 'forEach(GenericsError.Looper<? super T>)' is never used">forEach</warning>(final Looper<? super T> looper) {
      for (final T item : list) {
        looper.loopItem(item);
      }
    }

    private void forEach(final DeletingLooper<? super T> looper) {
      for (final T item : list) {
        looper.loopItem(item);
      }
    }
  }

  private interface Looper<T> {
    void loopItem(final T a);
  }

  private interface DeletingLooper<T> extends Looper<T> {
  }

  private static class MyDeletingLooper implements DeletingLooper<B> {
    @Override
    public void loopItem(final B a) {
    }
  }

  private class A {
  }

  private class B extends A {
  }

  public static void main(final String[] args) {
    final ListHolder<? extends B> aListHolder = new ListHolder<B>();
    final DeletingLooper<? super B> bLooper = new MyDeletingLooper();

    aListHolder.forEach(bLooper);
  }
}


text:
package Model;
// Generated Jan 14, 2011 3:39:55 PM by Hibernate Tools 3.2.1.GA

import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

/**
 * HsPrSalaryCurrencyDetail generated by hbm2java
 */
@Entity
@Table(name="hs_pr_salary_currency_detail"
    ,catalog="ashrm"
)
public class HsPrSalaryCurrencyDetail  implements java.io.Serializable {

     private HsPrSalaryCurrencyDetailId id;
     private Salarygrade salarygrade;
     private CurrencyType currencyType;
     private Double salcurrDtlMinsalary;
     private Double salcurrDtlStepsalary;
     private Double salcurrDtlMaxsalary;

    public HsPrSalaryCurrencyDetail() {
    }

    public HsPrSalaryCurrencyDetail(HsPrSalaryCurrencyDetailId id, Salarygrade salarygrade, CurrencyType currencyType) {
        this.id = id;
        this.salarygrade = salarygrade;
        this.currencyType = currencyType;
    }
    public HsPrSalaryCurrencyDetail(HsPrSalaryCurrencyDetailId id, Salarygrade salarygrade, CurrencyType currencyType, Double salcurrDtlMinsalary, Double salcurrDtlStepsalary, Double salcurrDtlMaxsalary) {
       this.id = id;
       this.salarygrade = salarygrade;
       this.currencyType = currencyType;
       this.salcurrDtlMinsalary = salcurrDtlMinsalary;
       this.salcurrDtlStepsalary = salcurrDtlStepsalary;
       this.salcurrDtlMaxsalary = salcurrDtlMaxsalary;
    }

     @EmbeddedId

    @AttributeOverrides( {
        @AttributeOverride(name="salGrdCode", column=@Column(name="sal_grd_code", nullable=false, length=13) ),
        @AttributeOverride(name="currencyId", column=@Column(name="currency_id", nullable=false, length=3) ) } )
    public HsPrSalaryCurrencyDetailId getId() {
        return this.id;
    }

    public void setId(HsPrSalaryCurrencyDetailId id) {
        this.id = id;
    }
@ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="sal_grd_code", nullable=false, insertable=false, updatable=false)
    public Salarygrade getSalarygrade() {
        return this.salarygrade;
    }

    public void setSalarygrade(Salarygrade salarygrade) {
        this.salarygrade = salarygrade;
    }
@ManyToOne(fetch=FetchType.LAZY)
    @JoinColumn(name="currency_id", nullable=false, insertable=false, updatable=false)
    public CurrencyType getCurrencyType() {
        return this.currencyType;
    }

    public void setCurrencyType(CurrencyType currencyType) {
        this.currencyType = currencyType;
    }

    @Column(name="salcurr_dtl_minsalary", precision=22, scale=0)
    public Double getSalcurrDtlMinsalary() {
        return this.salcurrDtlMinsalary;
    }

    public void setSalcurrDtlMinsalary(Double salcurrDtlMinsalary) {
        this.salcurrDtlMinsalary = salcurrDtlMinsalary;
    }

    @Column(name="salcurr_dtl_stepsalary", precision=22, scale=0)
    public Double getSalcurrDtlStepsalary() {
        return this.salcurrDtlStepsalary;
    }

    public void setSalcurrDtlStepsalary(Double salcurrDtlStepsalary) {
        this.salcurrDtlStepsalary = salcurrDtlStepsalary;
    }

    @Column(name="salcurr_dtl_maxsalary", precision=22, scale=0)
    public Double getSalcurrDtlMaxsalary() {
        return this.salcurrDtlMaxsalary;
    }

    public void setSalcurrDtlMaxsalary(Double salcurrDtlMaxsalary) {
        this.salcurrDtlMaxsalary = salcurrDtlMaxsalary;
    }

}


text:
package com.planet_ink.coffee_mud.Abilities.Common;
import com.planet_ink.coffee_mud.core.interfaces.*;
import com.planet_ink.coffee_mud.core.*;
import com.planet_ink.coffee_mud.core.collections.*;
import com.planet_ink.coffee_mud.Abilities.Common.CraftingSkill.CraftParms;
import com.planet_ink.coffee_mud.Abilities.interfaces.*;
import com.planet_ink.coffee_mud.Areas.interfaces.*;
import com.planet_ink.coffee_mud.Behaviors.interfaces.*;
import com.planet_ink.coffee_mud.CharClasses.interfaces.*;
import com.planet_ink.coffee_mud.Commands.interfaces.*;
import com.planet_ink.coffee_mud.Common.interfaces.*;
import com.planet_ink.coffee_mud.Exits.interfaces.*;
import com.planet_ink.coffee_mud.Items.interfaces.*;
import com.planet_ink.coffee_mud.Libraries.interfaces.*;
import com.planet_ink.coffee_mud.Locales.interfaces.*;
import com.planet_ink.coffee_mud.MOBS.interfaces.*;
import com.planet_ink.coffee_mud.Races.interfaces.*;

import java.util.*;

public class MasterWeaponsmithing extends Weaponsmithing implements ItemCraftor
{
	@Override
	public String ID()
	{
		return "MasterWeaponsmithing";
	}

	private final static String	localizedName	= CMLib.lang().L("Master Weaponsmithing");

	@Override
	public String name()
	{
		return localizedName;
	}

	private static final String[]	triggerStrings	= I(new String[] { "MWEAPONSMITH", "MASTERWEAPONSMITHING" });

	@Override
	public String[] triggerStrings()
	{
		return triggerStrings;
	}

	@Override
	protected int displayColumns()
	{
		return 2;
	}

	@Override
	public String getRecipeFilename()
	{
		return "masterweaponsmith.txt";
	}

	@Override
	protected List<List<String>> loadRecipes()
	{
		return super.loadRecipes(getRecipeFilename());
	}

	@Override
	protected boolean masterCraftCheck(final Item I)
	{
		if(I.ID().toUpperCase().startsWith("MASTER"))
			return true;
		if((I.basePhyStats().level()<31)||(I.basePhyStats().level()>60))
			return false;
		return true;
	}

	@Override
	protected boolean autoGenInvoke(final MOB mob, final List<String> commands, final Physical givenTarget, final boolean auto,
			 					 final int asLevel, final int autoGenerate, final boolean forceLevels, final List<CraftedItem> crafted)
	{
		if(super.checkStop(mob, commands))
			return true;

		if(super.checkInfo(mob, commands))
			return true;

		randomRecipeFix(mob,addRecipes(mob,loadRecipes()),commands,autoGenerate);
		if(commands.size()==0)
		{
			commonTell(mob,L("Make what? Enter \"mweaponsmith list\" for a list, \"mweaponsmith info <item>\", \"mweaponsmith scan\","
						+ " \"mweaponsmith learn <item>\", \"mweaponsmith mend <item>\", or \"mweaponsmith stop\" to cancel."));
			return false;
		}
		return super.autoGenInvoke(mob,commands,givenTarget,auto,asLevel,autoGenerate,forceLevels,crafted);
	}

}


text:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="ConsoleAppender" class="org.apache.log4j.ConsoleAppender">
        <!--<layout class="org.apache.log4j.SimpleLayout"/>-->
        <layout class="org.apache.log4j.EnhancedPatternLayout">
            <param name="ConversionPattern" value="%-5p [%t] %c.%M - %m%n %throwable{short}"/>
        </layout>
    </appender>
    <category name="io.sprint0">
        <priority value="debug"/>
    </category>
    <root>
        <priority value="info"/>
        <appender-ref ref="ConsoleAppender"/>
    </root>
</log4j:configuration>


text:
/*
  Module dependencies.
*/

var _ = require('lodash');
var async = require('async');
var eyes = require('eyes');
var util = require('util');
var utils = require('../../../utils');
var EventEmitter = require('events').EventEmitter;

module.exports = ResolvingRequest;

/*
  Quarry.io - Resolving Request
  ------------------------------

  represents a single backend query that might branch

 */

function ResolvingRequest(bayid, req, res){
  EventEmitter.call(this);

  var stampid = utils.quarryid();

  req.setHeader('x-quarry-bayid', bayid);
  req.setHeader('x-quarry-baystampid', stampid);

  this.bayid = bayid;
  this.id = stampid;
  this.requests = {};

  this.mainreq = req;
  this.mainres = res;

  this.branch(stampid);
}

util.inherits(ResolvingRequest, EventEmitter);

ResolvingRequest.prototype.trigger = function(){
  var is_complete = _.every(this.requests, function(val){
    return val;
  })

  if(is_complete){
    this.emit('complete');
    this.mainres.send();
  }
}

ResolvingRequest.prototype.branch = function(id){
  this.requests[id] = false;
  return this;
}

ResolvingRequest.prototype.branchcomplete = function(id, res){
  this.requests[id] = true;
  this.mainres.add(res);
  this.trigger();
}

ResolvingRequest.prototype.maincomplete = function(res){
  var self = this;
  // ON MAIN COMPLETE
  this.requests[this.id] = true;
  this.mainres.add(res);

  var branches = res.getHeader('x-json-branches') || {};

  /*

    the request has branched - trigger the branches
    then give one tick to settle down before triggering the
    main response

  */
  _.each(branches, function(v, branchid){
    self.branch(branchid);
  })

  process.nextTick(function(){
    self.trigger();
  })
}


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

public class Modules : MonoBehaviour
{

	public GameObject Model;
	private ModuleCreator Creator;

	public List<GameObject> _buildings = new List<GameObject> ();

	public GameObject _buildingsCanvas;
	public GameObject _sliderTime;
	public GameObject _constructionCanvas;

	public bool _landingZoneCreated;

	public GameObject _buttonLandingZone;

	public AudioSource _audio;

	public GameObject _BuildingMaterialsNumberInfo;
	public GameObject _HUD;
	// Use this for initialization
	void Awake ()
	{

		Creator = ModuleCreator.Instance;
		Creator.Initiate (1f);

		_buildingsCanvas = GameObject.Find ("Buildings");
		_sliderTime = GameObject.Find ("SlidderForSpeed");
		_constructionCanvas = GameObject.Find ("Construction");
		_buttonLandingZone = GameObject.Find ("LandingZoneButton");
		_BuildingMaterialsNumberInfo = GameObject.Find ("BuildingMaterialsNumber");
		_HUD = GameObject.Find ("HUDstats");
	}

	// Update is called once per frame
	void Update ()
	{
		if (Creator._OnSound == true) {
			_audio.Play ();
			Creator._OnSound = false;
		}

		if (Input.GetKeyDown (KeyCode.F1)) {
			Creator.Deploy (Model);
		}

		if (_landingZoneCreated == true) {
			_buttonLandingZone.GetComponent<CanvasGroup> ().alpha = 0;
			_buttonLandingZone.GetComponent<CanvasGroup> ().interactable = false;
			_buttonLandingZone.GetComponent<CanvasGroup> ().blocksRaycasts = false;
		}

		_BuildingMaterialsNumberInfo.GetComponent<Text> ().text = "" + Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials;
	}

	public void MedicalCenter ()
	{
		Creator._price = 50f;
		Model = _buildings [0];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void FoodProduction ()
	{
		Creator._price = 200f;

		Model = _buildings [1];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void SolarPanels ()
	{
		Creator._price = 200f;

		Model = _buildings [2];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void HumanHabitats ()
	{
		Creator._price = 1000f;

		Model = _buildings [3];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void WaterExtractionCenter ()
	{
		Creator._price = 200f;

		Model = _buildings [4];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void LandingZone ()
	{
		//_landingZoneCreated = true;

		Creator._price = 50f;

		Model = _buildings [5];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void RoverStation ()
	{
		Creator._price = 500f;

		Model = _buildings [6];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void WareHouse ()
	{
		Creator._price = 500f;

		Model = _buildings [7];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	public void ComTower ()
	{
		Creator._price = 50f;

		Model = _buildings [8];

		if (Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials >= Creator._price) {
			Creator.Deploy (Model);
			canvasOptions ();
		}
	}

	/*void OnGUI ()
	{
		GUIStyle myStyle = new GUIStyle ();
		myStyle.fontSize = 25;
		myStyle.normal.textColor = Color.white;
		GUI.Label (new Rect (Screen.width - 400, 100, 500, 30), "buildings materials: " + Camera.main.GetComponent<gameStats> ()._actualConstructionMaterials, myStyle);
	}*/

	void canvasOptions ()
	{
		_buildingsCanvas.GetComponent<CanvasGroup> ().alpha = 0;
		_buildingsCanvas.GetComponent<CanvasGroup> ().blocksRaycasts = false;
		_buildingsCanvas.GetComponent<CanvasGroup> ().interactable = false;

		_sliderTime.GetComponent<CanvasGroup> ().alpha = 1;
		_sliderTime.GetComponent<CanvasGroup> ().blocksRaycasts = true;
		_sliderTime.GetComponent<CanvasGroup> ().interactable = true;

		_constructionCanvas.GetComponent<CanvasGroup> ().alpha = 1;
		_constructionCanvas.GetComponent<CanvasGroup> ().blocksRaycasts = true;
		_constructionCanvas.GetComponent<CanvasGroup> ().interactable = true;

		_HUD.GetComponent<CanvasGroup> ().alpha = 1;
		_HUD.GetComponent<CanvasGroup> ().interactable = true;
	}
}


text:
'use strict';

const Hapi = require('hapi');
const HapiArch = require('hapi-arch');

const archPlugin = HapiArch({
  config: require('./.hapiarch.json')
});

const server = new Hapi.Server();

server.connection(CONFIG.connection);

let plugins = [archPlugin];
plugins = _.union(plugins, require('./thirdParty'));

/** register plugins then start the server. */
server.register(plugins, (err) => {

  if (err) throw err;

  // start the server connection.
  server.start((err) => {

    if (err) throw err;

    server.log('info', 'Server running at: ' + server.info.uri);

  });

});

module.exports = server;


text:
package com.contentful.androidcookies;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.speech.RecognizerIntent;
import android.support.wearable.view.WatchViewStub;
import butterknife.ButterKnife;
import butterknife.OnClick;
import com.contentful.androidcookies.shared.Constants;
import com.contentful.androidcookies.shared.Utils;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.wearable.Wearable;
import java.util.List;

/**
 * MainActivity.
 */
public class MainActivity extends Activity {
  private static final int SPEECH_REQUEST_CODE = 1;
  private GoogleApiClient googleApiClient;

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    initApiClient();

    WatchViewStub stub = (WatchViewStub) findViewById(R.id.watch_view_stub);
    stub.setOnLayoutInflatedListener(new WatchViewStub.OnLayoutInflatedListener() {
      @Override public void onLayoutInflated(WatchViewStub watchViewStub) {
        ButterKnife.inject(MainActivity.this);
      }
    });
  }

  @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == SPEECH_REQUEST_CODE && resultCode == RESULT_OK) {
      List<String> results = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
      if (results != null && results.size() > 0) {
        Utils.sendMessage(googleApiClient, Constants.PATH_CREATE_COOKIE, results.get(0).getBytes());
      }
    }
  }

  @OnClick(R.id.btn_create)
  void onClickCreate() {
    startActivityForResult(new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).putExtra(
        RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM),
        SPEECH_REQUEST_CODE);
  }

  @OnClick(R.id.btn_request)
  void onClickRequest() {
    Utils.sendMessage(googleApiClient, Constants.PATH_REQUEST_COOKIE);
  }

  private void initApiClient() {
    googleApiClient = new GoogleApiClient.Builder(this)
        .addApi(Wearable.API)
        .build();

    googleApiClient.connect();
  }
}