text:
/**
 * (c) 2010-2017 Torstein Honsi
 *
 * License: www.highcharts.com/license
 */
'use strict';
import H from '../parts/Globals.js';
import '../parts/Utilities.js';
import '../parts/Options.js';
import '../parts/Point.js';
import '../parts-more/BubbleSeries.js';
var merge = H.merge,
    Point = H.Point,
    seriesType = H.seriesType,
    seriesTypes = H.seriesTypes;

// The mapbubble series type
if (seriesTypes.bubble) {

    /**
     * A map bubble series is a bubble series laid out on top of a map series,
     * where each bubble is tied to a specific map area.
     *
     * @sample maps/demo/map-bubble/ Map bubble chart
     *
     * @extends {plotOptions.bubble}
     * @product highmaps
     * @optionparent plotOptions.mapbubble
     */
    seriesType('mapbubble', 'bubble', {

        /**
         * The main color of the series. This color affects both the fill and
         * the stroke of the bubble. For enhanced control, use `marker` options.
         *
         * @type {Color}
         * @sample {highmaps} maps/plotoptions/mapbubble-color/ Pink bubbles
         * @product highmaps
         * @apioption plotOptions.mapbubble.color
         */

        /**
         * Whether to display negative sized bubbles. The threshold is given
         * by the [zThreshold](#plotOptions.mapbubble.zThreshold) option, and
         * negative bubbles can be visualized by setting [negativeColor](
         * #plotOptions.bubble.negativeColor).
         *
         * @type {Boolean}
         * @default true
         * @product highmaps
         * @apioption plotOptions.mapbubble.displayNegative
         */

        /**
         * @sample    {highmaps} maps/demo/map-bubble/ Bubble size
         * @product   highmaps
         * @apioption plotOptions.mapbubble.maxSize
         */

        /**
         * @sample    {highmaps} maps/demo/map-bubble/ Bubble size
         * @product   highmaps
         * @apioption plotOptions.mapbubble.minSize
         */

        /**
         * When a point's Z value is below the [zThreshold](
         * #plotOptions.mapbubble.zThreshold) setting, this color is used.
         *
         * @type {Color}
         * @sample {highmaps} maps/plotoptions/mapbubble-negativecolor/
         *         Negative color below a threshold
         * @default null
         * @product highmaps
         * @apioption plotOptions.mapbubble.negativeColor
         */

        /**
         * Whether the bubble's value should be represented by the area or the
         * width of the bubble. The default, `area`, corresponds best to the
         * human perception of the size of each bubble.
         *
         * @validvalue ["area", "width"]
         * @type {String}
         * @default area
         * @product highmaps
         * @apioption plotOptions.mapbubble.sizeBy
         */

        /**
         * When this is true, the absolute value of z determines the size of
         * the bubble. This means that with the default `zThreshold` of 0, a
         * bubble of value -1 will have the same size as a bubble of value 1,
         * while a bubble of value 0 will have a smaller size according to
         * `minSize`.
         *
         * @type {Boolean}
         * @sample {highmaps} highcharts/plotoptions/bubble-sizebyabsolutevalue/
         *         Size by absolute value, various thresholds
         * @default false
         * @since 1.1.9
         * @product highmaps
         * @apioption plotOptions.mapbubble.sizeByAbsoluteValue
         */

        /**
         * The minimum for the Z value range. Defaults to the highest Z value
         * in the data.
         *
         * @type {Number}
         * @see [zMax](#plotOptions.mapbubble.zMin)
         * @sample {highmaps} highcharts/plotoptions/bubble-zmin-zmax/
         *         Z has a possible range of 0-100
         * @default null
         * @since 1.0.3
         * @product highmaps
         * @apioption plotOptions.mapbubble.zMax
         */

        /**
         * The minimum for the Z value range. Defaults to the lowest Z value
         * in the data.
         *
         * @type {Number}
         * @see [zMax](#plotOptions.mapbubble.zMax)
         * @sample {highmaps} highcharts/plotoptions/bubble-zmin-zmax/
         *         Z has a possible range of 0-100
         * @default null
         * @since 1.0.3
         * @product highmaps
         * @apioption plotOptions.mapbubble.zMin
         */

        /**
         * When [displayNegative](#plotOptions.mapbubble.displayNegative) is
         * `false`, bubbles with lower Z values are skipped. When
         * `displayNegative` is `true` and a [negativeColor](
         * #plotOptions.mapbubble.negativeColor) is given, points with lower Z
         * is colored.
         *
         * @type {Number}
         * @sample {highmaps} maps/plotoptions/mapbubble-negativecolor/
         *         Negative color below a threshold
         * @default 0
         * @product highmaps
         * @apioption plotOptions.mapbubble.zThreshold
         */

        animationLimit: 500,

        tooltip: {
            pointFormat: '{point.name}: {point.z}'
        }

    // Prototype members
    }, {
        xyFromShape: true,
        type: 'mapbubble',
        // If one single value is passed, it is interpreted as z
        pointArrayMap: ['z'],
        // Return the map area identified by the dataJoinBy option
        getMapData: seriesTypes.map.prototype.getMapData,
        getBox: seriesTypes.map.prototype.getBox,
        setData: seriesTypes.map.prototype.setData

    // Point class
    }, {
        applyOptions: function (options, x) {
            var point;
            if (
                options &&
                options.lat !== undefined &&
                options.lon !== undefined
            ) {
                point = Point.prototype.applyOptions.call(
                    this,
                    merge(
                        options,
                        this.series.chart.fromLatLonToPoint(options)
                    ),
                    x
                );
            } else {
                point = seriesTypes.map.prototype.pointClass.prototype
                    .applyOptions.call(this, options, x);
            }
            return point;
        },
        isValid: function () {
            return typeof this.z === 'number';
        },
        ttBelow: false
    });
}

/**
 * A `mapbubble` series. If the [type](#series.mapbubble.type) option
 * is not specified, it is inherited from [chart.type](#chart.type).
 *
 *
 * @type {Object}
 * @extends series,plotOptions.mapbubble
 * @excluding dataParser,dataURL
 * @product highmaps
 * @apioption series.mapbubble
 */

/**
 * An array of data points for the series. For the `mapbubble` series
 * type, points can be given in the following ways:
 *
 * 1.  An array of numerical values. In this case, the numerical values
 * will be interpreted as `z` options. Example:
 *
 *  ```js
 *  data: [0, 5, 3, 5]
 *  ```
 *
 * 2.  An array of objects with named values. The objects are point
 * configuration objects as seen below. If the total number of data points
 * exceeds the series' [turboThreshold](#series.mapbubble.turboThreshold),
 * this option is not available.
 *
 *  ```js
 *     data: [{
 *         z: 9,
 *         name: "Point2",
 *         color: "#00FF00"
 *     }, {
 *         z: 10,
 *         name: "Point1",
 *         color: "#FF00FF"
 *     }]
 *  ```
 *
 * @type {Array<Object|Number>}
 * @extends series.mappoint.data
 * @excluding labelrank,middleX,middleY,path,value,x,y,lat,lon
 * @product highmaps
 * @apioption series.mapbubble.data
 */

/**
 * While the `x` and `y` values of the bubble are determined by the
 * underlying map, the `z` indicates the actual value that gives the
 * size of the bubble.
 *
 * @type {Number}
 * @sample {highmaps} maps/demo/map-bubble/ Bubble
 * @product highmaps
 * @apioption series.mapbubble.data.z
 */

/**
 * @excluding enabled,enabledThreshold,height,radius,width
 * @apioption series.mapbubble.marker
 */


text:
git clean -xdf -e samples -e src/IdentityServer4/.vs

./clean_cache.ps1

redpajama_set_name: RedPajamaGithub


text:
import exec from './utils/exec';
import readline from 'readline';

export default (grunt) => {
  const publishConfig = grunt.config.get('packages').publish;
  const platforms = grunt.config.get('platforms');

  function debS3(deb) {
    exec('deb-s3', [
      'upload',
      '--preserve-versions',
      deb.filePath,
      '--bucket', deb.bucket,
      '--prefix', deb.prefix,
      '--sign', deb.signatureKeyId,
      '--arch', deb.arch,
      `--access-key-id=${deb.awsKey}`,
      `--secret-access-key=${deb.awsSecret}`,
      '--gpg-options=--digest-algo SHA512'
    ]);
  }

  function rpmS3(rpm) {
    exec('rpm', [
      '--resign', rpm.filePath,
      '--define', '_signature gpg',
      '--define', `_gpg_name ${rpm.signingKeyName}`
    ]);

    exec('rpm-s3', [
      '-v',
      '-b', rpm.bucket,
      '-p', rpm.prefix,
      '--sign',
      '--visibility', 'public-read',
      '-k', '100',
      rpm.filePath,
      '-r', 'external-1'
    ], {
      env: Object.assign({}, {
        'AWS_ACCESS_KEY': rpm.awsKey,
        'AWS_SECRET_KEY': rpm.awsSecret
      }, process.env)
    });
  }

  grunt.registerTask('publishPackages:staging', [
    '_publishPackages:confirm',
    '_publishPackages:upload:staging',
  ]);

  grunt.registerTask('publishPackages:production', [
    '_publishPackages:confirm',
    '_publishPackages:upload:production',
  ]);

  grunt.registerTask('_publishPackages:confirm', function () {
    function abort() {
      grunt.fail.fatal('Aborting publish');
    }

    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout
    });

    rl.on('close', this.async());
    rl.on('SIGINT', () => abort());
    rl.question('Publish packages to s3? [N/y] ', function (resp) {
      if (resp.toLowerCase().trim()[0] === 'y') return rl.close();
      abort();
    });
  });

  grunt.registerTask('_publishPackages:upload', function (environment) {
    const aws = grunt.file.readJSON('.aws-config.json');
    const signature = grunt.file.readJSON('.signing-config.json');

    platforms.forEach((platform) => {
      if (platform.debPath) {
        debS3({
          filePath: platform.debPath,
          bucket: publishConfig[environment].bucket,
          prefix: publishConfig[environment].debPrefix,
          signatureKeyId: signature.id,
          arch: platform.debArch,
          awsKey: aws.key,
          awsSecret: aws.secret
        });
      }

      if (platform.rpmPath) {
        rpmS3({
          filePath: platform.rpmPath,
          bucket: publishConfig[environment].bucket,
          prefix: publishConfig[environment].rpmPrefix,
          signingKeyName: signature.name,
          awsKey: aws.key,
          awsSecret: aws.secret
        });
      }
    });

  });
};


text:
package org.apache.oltu.commons.json;

import java.util.Formatter;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * TODO
 */
public abstract class CustomizableEntity {

    /**
     * The registry that keeps the custom fields.
     */
    private final Map<String, Object> customFields;

    /**
     * TODO
     *
     * @param customFields
     */
    public CustomizableEntity(Map<String, Object> customFields) {
        if (customFields == null) {
            throw new IllegalArgumentException("Null custom field registry not allowed.");
        }
        this.customFields = customFields;
    }

    /**
     * Return the specified custom field value,
     * {@code null} if the custom field is not present.
     *
     * @param name the custom field name, it cannot be null.
     * @return the specified custom field value,
     *         {@code null} if the custom field is not present.
     */
    public final <T> T getCustomField(String name, Class<T> type) {
        if (name == null) {
            throw new IllegalArgumentException("Null custom field name not present in the registry.");
        }

        Object value = customFields.get(name);

        if (value != null) {
            return type.cast(value);
        }

        return null;
    }

    /**
     * Returns the custom fields stored in the entity.
     *
     * @return the custom fields stored in the entity.
     */
    public final Set<Entry<String, Object>> getCustomFields() {
        return customFields.entrySet();
    }

    @Override
    public String toString() {
        if (customFields.isEmpty()) {
            return "";
        }

        Formatter formatter = new Formatter();

        formatter.format( ", " );

        int counter = 0;
        for (Entry<String, Object> customField : customFields.entrySet()) {
            Object value = customField.getValue();

            if (value != null) {
                if (counter++ > 0) {
                    formatter.format(", ");
                }

                String pattern;
                if (customField.getValue() instanceof Number) {
                    pattern = "\"%s\": %s";
                } else {
                    pattern = "\"%s\": \"%s\"";
                }

                formatter.format(pattern, customField.getKey(), value);
            }
        }

        try {
            return formatter.toString();
        } finally {
            formatter.close();
        }
    }

}


text:
.docbook .xref img[src^=images\/callouts\/],
.screen img,
.programlisting img,
.literallayout img,
.synopsis img {
    width: 1em;
}

.calloutlist img {
    width: 1.5em;
}

.prompt,
.screen img,
.programlisting img,
.literallayout img,
.synopsis img {
    -moz-user-select: none;
    -webkit-user-select: none;
    -ms-user-select: none;
    user-select: none;
}


text:
using UnityEngine;
using System.Collections;
using System.IO;
using UnityEngine.UI;
using System.Collections.Generic;
using Zeltex.Util;
using Zeltex.AnimationUtilities;

/// <summary>
/// Anything that is local and saved just for the player
/// Including:
///     - Player Name
///     - Graphics Options
///     - Sound Options
///     - Player Gui Options
/// </summary>
namespace Zeltex.Guis.Players
{
    /// <summary>
    /// Saves the player name in 'PlayerSettings.txt' file
    /// </summary>
    public class PlayerNameHandler : MonoBehaviour
    {
        public GameObject WhoAreYouTab;
        public GameObject WelcomeBackTab;
        //public SpeechAnimator MyWelcomeText;
        public InputField PlayerNameLabel;
        private string MyFileLocation;

        public Material MyCaretMaterial;

        // Load the player name here
        void Start ()
        {
            WhoAreYouTab.SetActive(true);
            WelcomeBackTab.SetActive(false);
            LoadName();
        }
        bool IsLoadingName = false;
        private void LoadName()
        {
            MyFileLocation = Application.persistentDataPath + "/PlayerSettings.txt";  //FileUtil.GetWorldFolderPath() +
            Debug.Log("Loading Player settings from [" + MyFileLocation + "]");
            if (FileUtil.DoesFileExist(MyFileLocation))
            {
                StreamReader MyStreamReader = new StreamReader(MyFileLocation);
                string MyFileText = MyStreamReader.ReadToEnd();
                if (MyFileText != "")
                {
                    WelcomeBackTab.SetActive(true);
                    WhoAreYouTab.SetActive(false);
                    //string MyText = File.ReadAllText(MyFileLocation);
                    IsLoadingName = true;
                    PlayerNameLabel.text = MyFileText;
                    IsLoadingName = false;
                }
                MyStreamReader.Close();
                if (MyFileText != "")
                {
                    UpdatePlayerName(MyFileText);
                }
            }
            else
            {
                Debug.Log("File not found.");
                WhoAreYouTab.SetActive(true);
            }
            StartCoroutine(ChangeInputMaterial());
        }
        /// <summary>
        /// UI function
        /// </summary>
        public void UpdatePlayerName(string NewName)
        {
            if (IsLoadingName == false)
            {
            Debug.Log("Saving Player settings from [" + MyFileLocation + "]");
            //PhotonNetwork.player.name = NewName;
            StreamWriter MyStreamWriter = new StreamWriter(MyFileLocation);
            MyStreamWriter.WriteLine(NewName);
            //File.WriteAllText(MyFileLocation, NewName);
            MyStreamWriter.Close();
            }
        }
        IEnumerator ChangeInputMaterial()
        {
            // wait a frame such that the caret GO gets created.
            yield return new WaitForSeconds(0.5f);  // wait one frame

            if (PlayerNameLabel)
            {
                // Find the child by name. This usually isnt good but is the easiest way for the time being.
                //InputField[] MyInputs = FindObjectsOfType(typeof(InputField)) as InputField[];
                List<InputField> MyInputs = GetAllObjectsInScene();
                foreach (InputField MyInput in MyInputs)
                {
                    if (MyInput)
                    {
                        //Debug.LogError(" Input: " + MyInput.name);
                        Transform MyCaret = MyInput.transform.GetChild(0);
                        if (MyCaret)
                            MyCaret.GetComponent<CanvasRenderer>().SetMaterial(MyCaretMaterial, Texture2D.whiteTexture);
                    }
                }
            }
        }

        List<InputField> GetAllObjectsInScene()
        {
            List<InputField> objectsInScene = new List<InputField>();

            foreach (InputField go in Resources.FindObjectsOfTypeAll(typeof(InputField)) as InputField[])
            {
                if (go.hideFlags == HideFlags.NotEditable || go.hideFlags == HideFlags.HideAndDontSave)
                    continue;
    //#if UNITY_EDITOR
                //if (!UnityEditor.EditorUtility.IsPersistent(go.transform.root.gameObject))
                //    continue;
    //#endif
                objectsInScene.Add(go);
            }
            return objectsInScene;
        }
    }
}
/*Transform MyCaret = PlayerNameLabel.transform.GetChild(0);
//FindChild(PlayerNameLabel.transform.name + " Input Caret");
if (MyCaret)
    MyCaret.GetComponent<CanvasRenderer>().SetMaterial(MyCaretMaterial, Texture2D.whiteTexture);
    */


text:
set(CMAKE_MRPT_HAS_MATLAB 0)

# Natural option to set ON the building of Matlab wrapper
# --------------------------------------------------------
if(MRPT_WITH_MATLAB_WRAPPER)

# Set sensible initial path for Matlab
if(NOT MATLAB_ROOT)
        if(WINDOWS) # In Windows
                set(MATLAB_ROOT "C:")
        else(WINDOWS) # In Linux
                set(MATLAB_ROOT "/usr/local/MATLAB")
        endif(WINDOWS)

        if(IS_DIRECTORY ${MATLAB_ROOT}) # Search installed versions in default directory
                file(GLOB LIST_MATLAB_INSTALLS RELATIVE ${MATLAB_ROOT} ${MATLAB_ROOT}/*)
                # Use first subdirectory (usually newest version)
                list(SORT LIST_MATLAB_INSTALLS) # Sort alphabetically
                list(REVERSE LIST_MATLAB_INSTALLS) # Reverse order
                list(GET LIST_MATLAB_INSTALLS 0 MATLAB_VERSION) # Take first element (highest version)

                set(MATLAB_ROOT "${MATLAB_ROOT}/${MATLAB_VERSION}")
        endif(IS_DIRECTORY ${MATLAB_ROOT})

        set(MATLAB_ROOT ${MATLAB_ROOT} CACHE PATH "Path to the MATLAB installation directory (e.g. /usr/local/MATLAB/R2012b, C:/... (TODO)")
        set(MATLAB_VERSION ${MATLAB_VERSION} CACHE STRING "R...-like version to use from installed ones")
endif(NOT MATLAB_ROOT)

# DISABLE_MATLAB
# ---------------------
option(DISABLE_MATLAB "Force not using Matlab" "OFF")
mark_as_advanced(DISABLE_MATLAB)
if(NOT DISABLE_MATLAB)

# Use CMAKE module if Matlab's not been detected yet:
if(NOT CMAKE_MRPT_HAS_MATLAB)
# TODO: This behaviour does not allow to update found libraries if MATLAB_ROOT is changed
		find_package(Matlab)
		if(MATLAB_FOUND)
				set(CMAKE_MRPT_HAS_MATLAB 1)

        list(APPEND MATLAB_LINK_LIBRARIES ${MATLAB_LIBRARIES} )

				# ----------------------------------------------------
				# Windows & MSVC: Mark Matlab DLLs as "delay-load", so
				#  non-mex apps can be run standalone without MATLAB:
				# ----------------------------------------------------
				if (MSVC)
          list(APPEND MATLAB_LINK_LIBRARIES "delayimp.lib")
					# Flags /DELAYLOAD:... added in DeclareMRPTLib.cmake
				endif (MSVC)

				# MEXPLUS header-only lib to handle mxArray class:
				add_subdirectory("${MRPT_SOURCE_DIR}/3rdparty/mexplus/")
				include_directories("${MRPT_SOURCE_DIR}/3rdparty/mexplus/")
		else(MATLAB_FOUND)
			message("MATLAB not found. Either set MATLAB_ROOT correctly, or set MRPT_WITH_MATLAB_WRAPPER=OFF")
		endif(MATLAB_FOUND)
endif(NOT CMAKE_MRPT_HAS_MATLAB)

# It seems it works with dynamic libraries too now!
## Set special options for Matlab wrapper compatibility
#if(BUILD_SHARED_LIBS)
#        message(SEND_ERROR
#"BUILD_SHARED_LIBS is activated.
#Static libraries are needed for MEX libraries due to TLS limitation in Matlab. Deactivate BUILD_SHARED_LIBRARIES.")
#endif(BUILD_SHARED_LIBS)

## Since MEX libraries are dynamic but MRPT libraries need to be static, the static libraries must be Position Independent Code (PIC)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

# Copy all .m files (classes, samples, helpers...) to the build directory
file(COPY ${MRPT_SOURCE_DIR}/mex/+mrpt   DESTINATION ${CMAKE_BINARY_DIR}/mex)
file(COPY ${MRPT_SOURCE_DIR}/mex/samples DESTINATION ${CMAKE_BINARY_DIR}/mex)
# Copy setup file and README
file(COPY ${MRPT_SOURCE_DIR}/mex/mrpt_setup.m DESTINATION ${CMAKE_BINARY_DIR}/mex)
file(COPY ${MRPT_SOURCE_DIR}/mex/README.txt   DESTINATION ${CMAKE_BINARY_DIR}/mex)

endif(NOT DISABLE_MATLAB)

endif(MRPT_WITH_MATLAB_WRAPPER)


text:
require 'spec_helper'
require 'component_helper'
require 'java_buildpack/container/spring_boot'

describe JavaBuildpack::Container::SpringBoot do
  include_context 'component_helper'

  it 'detects a dist Spring Boot application',
     app_fixture: 'container_spring_boot_dist' do

    expect(component.detect).to eq('spring-boot=1.0.0.RELEASE')
  end

  it 'detects a staged Spring Boot application',
     app_fixture: 'container_spring_boot_staged' do

    expect(component.detect).to eq('spring-boot=1.0.0.RELEASE')
  end

  it 'does not detect a non-Spring Boot application',
     app_fixture: 'container_main' do

    expect(component.detect).to be_nil
  end

  it 'does not detect a Ratpack application',
     app_fixture: 'container_ratpack_dist' do

    expect(component.detect).to be_nil
  end

  it 'does not detect a distZip application',
     app_fixture: 'container_dist_zip' do

    expect(component.detect).to be_nil
  end

  it 'does not detect a Play application',
     app_fixture: 'container_play_2.2_dist' do

    expect(component.detect).to be_nil
  end

  it 'extends the classpath',
     app_fixture: 'container_spring_boot_staged' do

    component.compile

    expect((app_dir + 'bin/application').read)
      .to match 'CLASSPATH=\$APP_HOME/.additional_libs/test-jar-1.jar:\$APP_HOME/.additional_libs/test-jar-2.jar:'
  end

  it 'returns command',
     app_fixture: 'container_spring_boot_staged' do

    expect(component.release).to eq("#{env_vars_str} #{java_home.as_env_var} " \
                                      "JAVA_OPTS=#{java_opts_str} exec $PWD/bin/application")
  end

  def env_vars_str
    environment_variables.join(' ')
  end

  def java_opts_str
    "\"#{java_opts.join(' ')}\""
  end

end


text:
<md-dialog class="md-dialog-fullscreen">
    <md-content class="md-padding">

            <md-input-container class="md-block" flex-gt-sm>
                Title
                <input type="text">
            </md-input-container>

        <md-input-container class="md-block" flex-gt-sm>
            <input type="text" placeholder="enter the url here">
        </md-input-container>
        <form>
            <md-chips name="skills" ng-model="selectedSkills" md-autocomplete-snap md-transform-chip="transformChip($chip)" md-max-chips="5" readonly="readonly" md-removable="removable" md-require-match="autocompleteDemoRequireMatch">
                <md-autocomplete md-selected-item="selectedItem" md-search-text="searchText" md-items="item in querySearch(searchText)" md-item-text="item.name" placeholder="Enter upto 5 skills">
                    {{item.name}}
                </md-autocomplete>
                <md-chip-template>

          {{$chip.name}}

                </md-chip-template>
            </md-chips>
        </form>

    </md-content>
</md-dialog>


text:
import sys

for line in sys.stdin:
    sys.stdout.write(line)


text:
typedef uint8_t uint8;
typedef uint32_t uint32;
typedef uint64_t uint64;

struct pair {
  uint64 first;
  uint64 second;
};

typedef struct pair uint128;

static inline uint64 Uint128Low64(const uint128 x) { return x.first; }
static inline uint64 Uint128High64(const uint128 x) { return x.second; }

// Hash function for a byte array.
uint64 CityHash64(const char *buf, size_t len);

// Hash function for a byte array.  For convenience, a 64-bit seed is also
// hashed into the result.
uint64 CityHash64WithSeed(const char *buf, size_t len, uint64 seed);

// Hash function for a byte array.  For convenience, two seeds are also
// hashed into the result.
uint64 CityHash64WithSeeds(const char *buf, size_t len,
                           uint64 seed0, uint64 seed1);

// Hash function for a byte array.
uint128 CityHash128(const char *s, size_t len);

// Hash function for a byte array.  For convenience, a 128-bit seed is also
// hashed into the result.
uint128 CityHash128WithSeed(const char *s, size_t len, uint64 first,
                            uint64 second);

// Hash 128 input bits down to 64 bits of output.
// This is intended to be a reasonably good hash function.
static inline uint64 Hash128to64(const uint64 u, const uint64 v) {
  // Murmur-inspired hashing.
  const uint64 kMul = 0x9ddfea08eb382d69ULL;
  uint64 a = (v ^ u) * kMul, b;
  a ^= (a >> 47);
  b = (v ^ a) * kMul;
  b ^= (b >> 47);
  b *= kMul;
  return b;
}

// Conditionally include declarations for versions of City that require SSE4.2
// instructions to be available.
#if defined(__SSE4_2__) && defined(__x86_64__)

// Hash function for a byte array.
uint128 CityHashCrc128(const char *s, size_t len);

// Hash function for a byte array.  For convenience, a 128-bit seed is also
// hashed into the result.
uint128 CityHashCrc128WithSeed(const char *s, size_t len, uint128 seed);

// Hash function for a byte array.  Sets result[0] ... result[3].
void CityHashCrc256(const char *s, size_t len, uint64 *result);

#endif  // __SSE4_2__

#endif  // CITY_HASH_H_


text:
layout: post
date: 2015-10-28
title: "Jenny Packham GRACE Short Sleeves Floor-Length Sheath/Column"
category: Jenny Packham
tags: [Jenny Packham,Sheath/Column,Illusion,Floor-Length,Short Sleeves]
---
### Jenny Packham GRACE
Just **$449.99**
###   Short Sleeves Floor-Length Sheath/Column

BRANDS	Jenny Packham

Silhouette	Sheath/Column

Neckline	Illusion

Hemline/Train	Floor-Length

Sleeve	Short Sleeves

Buy it: [https://www.readybrides.com/en/jenny-packham/35392-jenny-packham-grace.html](https://www.readybrides.com/en/jenny-packham/35392-jenny-packham-grace.html)


text:
// --------------------------------------------------------------------------------------------------------------------
// Copyright (c) Lead Pipe Software. All rights reserved.
// Licensed under the MIT License. Please see the LICENSE file in the project root for full license information.
// --------------------------------------------------------------------------------------------------------------------

/*
 * About This Example
 * --------------------------------------------------------------------------------------------------------------------
 * This is an example of how you might use a Finite State Machine implementation in order to give something (a garage
 * door in our case) FSM characteristics and capabilities. By using the FSM implementation, we're standardizing how
 * these characteristics and capabilities are granted as well as taking advantage of features such as History. Without
 * a reasonable FSM implementation, business rules, codes, statuses, states, and so forth can become scattered and hard
 * to decipher and debug.
 *
 * It should be noted that this particular example is moderately verbose. It isn't necessary to define all of the
 * methods, properties, enumerations, and so forth as shown here. It's also not necessary to put everything into a
 * single class. You may choose to use partial classes or even create your own FSM that the owning type holds a single
 * reference to. Ultimately, you have to decide what's right based on the circumstances.
 *
 * Finite State Machine
 * --------------------------------------------------------------------------------------------------------------------
 * A Finite State Machine (FSM) is the mechanism by which we can model an abstract machine by defining a finite number
 * of States as well as the Transitions between those States. For example, a door may be considered an FSM in that it
 * has States (open and closed) as well as Transitions (open and close) that are triggered by Events (opened and
 * closed) that are invoked by object methods (door.Open and door.Close).
 *
 * State
 * --------------------------------------------------------------------------------------------------------------------
 * The values of an object's attributes represent State. For example, if a door is anything more than closed then it
 * is considered to be in the open state (Door.PercentOpen > 0).
 *
 * Transitions
 * --------------------------------------------------------------------------------------------------------------------
 * When certain Events occur, an object progresses from one State to another. For example, when a door (object) is
 * opened (Event), it changes (Transition) from closed (State) to open (State). Each State defines what is possible by
 * registering Transitions. Each Transition causes the object to arrive at a particular State. Transitions often have
 * one or more business rules that determine if the they can be executed.
 *
 * Transition Reasons
 * --------------------------------------------------------------------------------------------------------------------
 * When a Transition occurs, we often want to know why it occurred. For example, when a door transitions from closed to
 * open, we might like to know why. The simplest form is to simply say that the reason it transitioned from closed to
 * open is because it was opened. On the other hand, if our door were perhaps the door to a bank vault, we might want
 * more explicit reasons such as "Depositing Money", "Withdrawing Money", and "Security Check".
 *
 * Events
 * --------------------------------------------------------------------------------------------------------------------
 * When something important happens to an object, it is considered an Event. For example, when someone encounters a
 * door (object) that is closed (State), they may choose to open it (object.Method) which causes the door to be opened
 * (Event) which, in turn, causes it to change (Transition) from closed (State) to open (State).
 *
 * A Note About Status Versus State
 * --------------------------------------------------------------------------------------------------------------------
 * It's far too common for novices to confuse State with Status. In some cases, a literal one-to-one translation is
 * just fine. For example, it may be enough to say that a door's Status is the same as its State (open or closed). More
 * often than not, however, Status is actually more than just State. For example, while a door's State is either open
 * or closed, it's Status might be open, closed and unlocked, closed and locked, and so on. In other words, Status is
 * often just a read-only representation of a combination of State with other information.
 */

using LeadPipe.Net.Extensions;
using LeadPipe.Net.FiniteStateMachine;
using System.Linq;

namespace LeadPipe.Net.Tests.FiniteStateMachineTests
{
    /// <summary>
    /// The garage door.
    /// </summary>
    public class GarageDoor
    {
        /// <summary>
        /// The garage door closed state.
        /// </summary>
        private IFiniteState closedState;

        /// <summary>
        /// The garage door close transition.
        /// </summary>
        private IFiniteStateTransition closeTransition;

        /// <summary>
        /// The garage door lock transition.
        /// </summary>
        private IFiniteStateTransition lockTransition;

        /// <summary>
        /// The garage door open state.
        /// </summary>
        private IFiniteState openState;

        /// <summary>
        /// The garage door open transition.
        /// </summary>
        private IFiniteStateTransition openTransition;

        /// <summary>
        /// The finite state machine.
        /// </summary>
        private IFiniteStateMachine<FiniteStateMachineHistoryEntry> stateMachine;

        /// <summary>
        /// Initializes a new instance of the <see cref="GarageDoor"/> class.
        /// </summary>
        public GarageDoor()
        {
            this.InitializeStateMachine();
        }

        /// <summary>
        /// The garage door states.
        /// </summary>
        public enum GarageDoorState
        {
            /// <summary>
            /// The garage door is open.
            /// </summary>
            Open,

            /// <summary>
            /// The garage door is closed.
            /// </summary>
            Closed
        }

        /// <summary>
        /// The garage door transitions.
        /// </summary>
        private enum GarageDoorTransition
        {
            /// <summary>
            /// Open the garage door.
            /// </summary>
            Open,

            /// <summary>
            /// Close the garage door.
            /// </summary>
            Close,

            /// <summary>
            /// Lock the garage door.
            /// </summary>
            Lock
        }

        /// <summary>
        /// Gets a value indicating whether the garage door can close.
        /// </summary>
        public bool CanClose
        {
            get
            {
                return this.stateMachine.CurrentState.Equals(this.openState);
            }
        }

        /// <summary>
        /// Gets a value indicating whether the garage door can lock.
        /// </summary>
        public bool CanLock
        {
            get
            {
                return !this.stateMachine.CurrentState.Equals(this.IsLocked);
            }
        }

        /// <summary>
        /// Gets a value indicating whether the garage door can open.
        /// </summary>
        public bool CanOpen
        {
            get
            {
                return this.stateMachine.CurrentState.Equals(this.closedState) && this.IsLocked.IsFalse();
            }
        }

        /// <summary>
        /// Gets a value indicating whether the garage door can be unlocked.
        /// </summary>
        public bool CanUnlock
        {
            get
            {
                return this.IsClosed && this.IsLocked;
            }
        }

        /// <summary>
        /// Gets the current state of the garage door.
        /// </summary>
        public GarageDoorState CurrentState
        {
            get
            {
                return (GarageDoorState)this.stateMachine.CurrentState.Code;
            }
        }

        /// <summary>
        /// Gets a value indicating whether the garage door is closed.
        /// </summary>
        public bool IsClosed
        {
            get
            {
                return this.stateMachine.CurrentState.Equals(this.closedState);
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the garage door is locked.
        /// </summary>
        public bool IsLocked { get; protected set; }

        /// <summary>
        /// Gets a value indicating whether the garage door is open.
        /// </summary>
        public bool IsOpen
        {
            get
            {
                return this.stateMachine.CurrentState.Equals(this.openState);
            }
        }

        /// <summary>
        /// Gets the number of times the garage door has been opened.
        /// </summary>
        public int OpenCount
        {
            get
            {
                return this.stateMachine.History.Entries.Count(x => x.StateCode.Equals(this.openState.Code));
            }
        }

        /// <summary>
        /// Closes the garage door.
        /// </summary>
        public void Close()
        {
            this.stateMachine.PerformTransition(this.closeTransition);
        }

        /// <summary>
        /// Locks the garage door.
        /// </summary>
        public void Lock()
        {
            // If the door isn't closed then close it...
            if (!this.IsClosed)
            {
                this.stateMachine.PerformTransition(this.closeTransition);
            }

            this.stateMachine.PerformTransition(this.lockTransition);

            this.IsLocked = true;
        }

        /// <summary>
        /// Opens the garage door.
        /// </summary>
        public void Open()
        {
            this.stateMachine.PerformTransition(this.openTransition);
        }

        /// <summary>
        /// Unlocks the garage door.
        /// </summary>
        public void Unlock()
        {
            if (this.CanUnlock)
            {
                this.IsLocked = false;
            }
        }

        /// <summary>
        /// Initializes the garage door state machine.
        /// </summary>
        private void InitializeStateMachine()
        {
            // Create the garage door states...
            this.openState = new FiniteState((int)GarageDoorState.Open, "Open");
            this.closedState = new FiniteState((int)GarageDoorState.Closed, "Closed");

            // Create the garage door transitions...
            this.openTransition = new FiniteStateTransition(
                (int)GarageDoorTransition.Open,
                "Open",
                new FiniteStateMachineTransitionReason("Opened"),
                this.openState,
                () => this.openState,
                () => this.CanOpen);

            this.lockTransition = new FiniteStateTransition(
                (int)GarageDoorTransition.Lock,
                "Lock",
                new FiniteStateMachineTransitionReason("Closed and Locked"),
                this.closedState,
                () => this.closedState,
                () => this.CanLock);

            this.closeTransition = new FiniteStateTransition(
                (int)GarageDoorTransition.Close,
                "Close",
                new FiniteStateMachineTransitionReason("Closed"),
                this.closedState,
                () => this.closedState,
                () => this.CanClose);

            // Register the garage door transitions with their respective garage door states...
            this.openState.RegisterTransition(this.closeTransition);
            this.openState.RegisterTransition(this.lockTransition);
            this.closedState.RegisterTransition(this.openTransition);
            this.closedState.RegisterTransition(this.lockTransition);

            // Create the garage door state machine...
            this.stateMachine = new FiniteStateMachine.FiniteStateMachine(this.openState);

            // Register the garage door states with the garage door state machine...
            this.stateMachine.RegisterState(this.openState);
            this.stateMachine.RegisterState(this.closedState);
        }
    }
}


text:
package models.daos

import java.util.UUID

import models.AuthToken

import scala.concurrent.Future

/**
 * Give access to the [[AuthToken]] object.
 */
trait AuthTokenDAO {

  /**
   * Finds a token by its ID.
   *
   * @param id The unique token ID.
   * @return The found token or None if no token for the given ID could be found.
   */
  def find(id: UUID): Future[Option[AuthToken]]

  /**
   * Saves a token.
   *
   * @param token The token to save.
   * @return The saved token.
   */
  def save(token: AuthToken): Future[AuthToken]

  /**
   * Removes the token for the given ID.
   *
   * @param id The ID for which the token should be removed.
   * @return A future to wait for the process to be completed.
   */
  def remove(id: UUID): Future[Int]
}


text:
layout: demo
  title: Demo
  docs: buttons
---

    Back

Buttons

    Button

A button in the content area:

    Label

A primary button:

    Label

A subtle button:

    Label

A disabled button:

    Label

    Button


text:
'use strict';

const SimpleSlackbot = require('simple-slackbot');

let name = 'kevbot';
let token = process.env.token || '123456';
let emoji = ':kevbot:';
let hooks = {
	onChannelMention: function (reply, message, fromUser) {
		reply(`It's bouncing around the Web like a beachball at a Nickelback concert.`);
	},
	onDirectMessage: function (reply, message, fromUser) {
		reply(`I'm pretty sure I've partied before, ${fromUser.name}.`);
	},
	onStart: function (reply) {
		reply(`Kevbot is back online.`); // All channels bot is a member of
	}
};
let triggers = {
	'action': function (reply, message) {
		reply('You just typed !action');
	}
};

let kevbot = new SimpleSlackbot(name, token, emoji, hooks, triggers);
kevbot.run();


text:
using Nucleus.Base;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Nucleus.Model
{
    /// <summary>
    /// Generic base for filters that pass or fail based
    /// on the assigned family of an element
    /// </summary>
    /// <typeparam name="TElement"></typeparam>
    /// <typeparam name="TFamily"></typeparam>
    [Serializable]
    public abstract class FamilyFilter<TElement, TFamily> : SetFilterBase<TElement>
        where TElement : Element
        where TFamily : Family
    {
        #region Properties

        /// <summary>
        /// Private backing field for Family property
        /// </summary>
        private TFamily _Family;

        /// <summary>
        /// The family to filter by
        /// </summary>
        public TFamily Family
        {
            get { return _Family; }
            set { _Family = value; }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Does the specified item pass through this filter?
        /// </summary>
        /// <param name="item">The item to be tested</param>
        /// <returns>True if the item passes through the filter, false if not.</returns>
        public override bool Pass(TElement item)
        {
            return (item.GetFamily() == Family) != Invert;
        }

        #endregion
    }

    /// <summary>
    /// Filter for elements which will pass if the element is assigned
    /// a specific family
    /// </summary>
    [Serializable]
    public class FamilyFilter : FamilyFilter<Element, Family>
    {
        #region Constructors

        /// <summary>
        /// Initialise a new blank FamilyFilter
        /// </summary>
        public FamilyFilter() { }

        /// <summary>
        /// Initialise a new FamilyFilter to pass elements
        /// with the specified family
        /// </summary>
        /// <param name="family"></param>
        /// <param name="invert"></param>
        public FamilyFilter(Family family, bool invert = false)
        {
            Family = family;
            Invert = invert;
        }

        #endregion
    }
}


text:
"""

    baidu ocr

"""

from aip import AipOcr

def get_text_from_image(image_data, app_id, app_key, app_secret, api_version=0, timeout=3):
    """
    Get image text use baidu ocr

    :param image_data:
    :param app_id:
    :param app_key:
    :param app_secret:
    :param timeout:
    :return:
    """
    client = AipOcr(appId=app_id, apiKey=app_key, secretKey=app_secret)
    client.setConnectionTimeoutInMillis(timeout * 1000)

    options = {}
    options["language_type"] = "CHN_ENG"

    if api_version == 1:
        result = client.basicAccurate(image_data, options)
    else:
        result = client.basicGeneral(image_data, options)

    if "error_code" in result:
        print("baidu api error: ", result["error_msg"])
        return ""
    return [words["words"] for words in result["words_result"]]


text:
require "active_record/with/version"
require "active_record/with/query_methods"

module ActiveRecord
  module With
    # Your code goes here...
  end
end


text:
/** @namespace */
var FluidGraph = function (firstBgElement){
  /*
  *
  *           Initialisation
  *
  ****************************/

  //Help to assure that it's the "this" of myGraph object
  var thisGraph = this;

  /**
   * Configuration Object
   * @memberof FluidGraph
   */
  thisGraph.config = {
    backgroundColor : "#F5F5F5",
    xNewNode : 200,
    yNewNode : 100,
    bgElementType : "panzoom", //choixe : "panzoom" or "simple"
    force : "Off",
    elastic : "Off",
    curvesLinks : "On",
    openNodeOnHover : "Off",
    displayIndex : "Off",
    proportionalNodeSize : "On",
    makeLinkSelectingNode : "Off", // default : Off
    linkDistance : 200,
    charge : -1000,
    debug : false,
    version : "loglink46",
    curvesLinksType : "diagonal", // choice : "curve" or "diagonal" default : "curve"
    viewerButtonLabel : "Launch Carto PAIR !",
    bringNodeToFrontOnHover : false,
    repulseNeighbourOnHover : false,
    awsomeStrokeNode : true,
    remindSelectedNodeOnSave : true,
    editGraphMode : false, // only use for checkbox
    allowDraggingNode : false, // default : false
    allowModifyLink : false, // default : false
    allowOpenNode : false, // default : false
    editWithDoubleClick : false, // default : false
    newNodeWithDoubleClickOnBg : false, // default : false
    allowDragOnBg : false,
    clicOnNodeAction : "options", // options, flod
    customOptions : {
      edit : true,
      center : true,
      focusContextOn : true,
      focusContextOff : true,
      hypertext : true,
      close : true,
      delete : true,
    }
  };

  /**
   * Base properties of the nodes
   * @memberof FluidGraph
   */
  thisGraph.customNodes = {
    strokeWidth : 10,
    strokeOpacity : .5,
    displayType : "On",
    displayText : "On",
    strokeOpacityGhostNeighbour : 1,
    listType : ["av:project","av:actor","av:idea","av:ressource","av:without"],
    colorType : {"av:project" : "#89A5E5",
                  "av:actor" : "#F285B9",
                  "av:idea" : "#FFD98D",
                  "av:ressource" : "#CDF989",
                  "av:without" : "#999",
                  "av:gray" : "gray"},
  	colorTypeRgba : {"av:project" : "137,165,229",
                      "av:actor" : "242,133,185",
                      "av:idea" : "255,217,141",
                      "av:ressource" : "205,249,137",
                      "av:without" : "255,255,255",
                      "av:gray" : "200,200,200"},
    strokeColor : "#CCC",
    strokeNeighbourColorType : {"av:project" : "#89A5E5",
                  "av:actor" : "#F285B9",
                  "av:idea" : "#FFD98D",
                  "av:ressource" : "#CDF989",
                  "av:without" : "#999"},
    strokeNeighbourColorTypeRgba : {"av:project" : "137,165,229",
                  "av:actor" : "242,133,185",
                  "av:idea" : "255,217,141",
                  "av:ressource" : "205,249,137",
                  "av:without" : "255,255,255"},
    neighbourColorTypeRgba : {"av:project" : "137,165,229",
                              "av:actor" : "242,133,185",
                              "av:idea" : "255,217,141",
                              "av:ressource" : "205,249,137",
                              "av:without" : "255,255,255"},
    imageType : {"av:project" : "lab", "av:actor" : "user", "av:idea" : "idea", "av:ressource" : "tree", "av:without" : "circle thin"},
    maxCharactersInLabel : 50,
    cursor : "move", //Value : grab or move (default), pointer, context-menu, text, crosshair, default
    cursorOpen : "default", //Value : grab or move (default), pointer, context-menu, text, crosshair, default
		heightClosed : 50,
    maxRadius : 40,

    // Width...
    widthClosed : 50,
    widthOpened : 260,
    widthOpenedNeighboursBox : 250,
    widthOpenedNeighbours : 220,
    widthGhostNeighbourImage : 30,
    widthGhostNeighbourTxt : 150,
    widthGhostNeighbourButton : 30,
    widthEdited : 220,
    widthEditedDescription : 180,
    widthEditedHypertext : 180,
    widthStrokeHover : 20,
    indiceProp : 2,

    // Height...
    heightOpened : 280,
    heightOpenedLabel : 50,
    heightOpenedOption : 20,
    heightOpenedNeighbour : 25,
    heightOpenedNeighboursMax : 200,
    heightGhostNeighbour : 40,
    heightGhostNeighbourTxt : 20,
    heightGhostNeighbourTxtMax : 70,
		heightEdited : 280,
    heightEditedDescription :80,
    heightEditedHypertext :60,

    maxCharactersInOpenNodeLabel : 50,
    maxCharactersInNeighbours : 20,
    curvesCornersClosedNode : 50,
    curvesCornersEditedNode : 20,
    curvesCornersOpenedNode : 20,

    // Transition...
		transitionEasing : "elastic", //Values : linear (default), elastic
    transitionDurationOpen : 300,
    transitionDurationEdit : 1000,
    transitionDurationClose : 300,
    transitionDurationComeBack : 500,
    transitionDurationConnector : 1500,
    transitionDurationCenterNode : 1200,
		transitionDelay : 0,
    blankNodeLabel : "",
    blankNodeType : "av:without",
    uriBase : "http://fluidlog.com/node/", //Warning : with LDP, no uriBase... :-)
    neighbourConnectorMessage : "Come here to create a link !",
    dropNodeInNeighboursMessage : "Yes ! Now, drop it to create a new neighbour !",
    neighbourConnectorOpacity : .9,
    neighbourConnectorOpacityDropped : 1,
    heightVideoInNode : 200,
  }

  if (thisGraph.config.awsomeStrokeNode == true)
  {
    thisGraph.customNodes.strokeColorType = {"av:project" : "#CCC",
                  "av:actor" : "#CCC",
                  "av:idea" : "#CCC",
                  "av:ressource" : "#CCC",
                  "av:without" : "#CCC"}
  }
  else {
    thisGraph.customNodes.strokeColorType = {"av:project" : "#89A5E5",
                  "av:actor" : "#F285B9",
                  "av:idea" : "#FFD98D",
                  "av:ressource" : "#CDF989",
                  "av:without" : "#999"}
  }

  thisGraph.nodeTypeIcon = {
    r : 13,
    cxClosed : 0,
    cxEdited : 0,
    cyClosed : (thisGraph.customNodes.heightClosed/2)-10,
    cyEdited : (thisGraph.customNodes.heightEdited/2)-10,
    xClosed : -11,
    xOpened : -11,
    xEdited : -11,
    yClosed : (thisGraph.customNodes.heightClosed/2)-20,
    yEdited : (thisGraph.customNodes.heightEdited/2)-20,
  }

  thisGraph.nodeIndexCircle = {
    r : 10,
    cxClosed : 0,
    cyClosed : -(thisGraph.customNodes.heightClosed/2)+6,
    cxEdited : 0,
    cyEdited : -(thisGraph.customNodes.heightOpened/2),
    dxClosed : 0,
    dyClosed : -(thisGraph.customNodes.heightClosed/2)+10,
    dxEdited : 0,
    dyEdited : -(thisGraph.customNodes.heightOpened/2)+5,
  }

  thisGraph.customNodesText = {
    fontSize : 14,
    FontFamily : "Helvetica Neue, Helvetica, Arial, sans-serif;",
    strokeOpacity : .5,
    widthMax : 160,
		heightMax : 60,
    curvesCorners : thisGraph.customNodes.curvesCornersOpenedNode,
  }

  thisGraph.customLinks = {
    strokeWidth: 3,
    strokeColor: "#CCC",
    strokeColorError: "#FDAAAA",
    strokeSelectedColor: "#999", //See also fluidgraph.css
    uriBase : "http://fluidlog.com/edge/", //Warning : with LDP, no uriBase... :-)
    predicate : "loglink:linkedto",
    transitionDurationOverLinks : 300,
  }

  thisGraph.customLinksLabel = {
    width : 200,
    height : 80,
    fillColor : "#CCC",
    strokeColor : "#DDD",
    curvesCorners : 20,
    blankNodeLabel : "loglink:linkto",
  }

  thisGraph.svgContainer = {
    width : window.innerWidth - 30,
    height : window.innerHeight - 30,
  }

  /**
   * Mouse event variables
   * @memberof FluidGraph
   */
  thisGraph.state = {
    selectedNode : null,
    selectedLink : null,
    mouseDownNode : null,
    mouseDownLink : null,
    svgMouseDownNode : null,
    mouseUpNode : null,
    lastKeyDown : -1,
    editedNode : null,
    editedIndexNode : null,
    openedNode : null,
    editedLinkLabel : null,
    dragStarted : null,
    draggingNode : null,
    draggingNodeSvg : null,
    targetNode : null,
    targetNodeSvg : null,
    focusMode : null,
    dNeighbourConnector : null,
    neighbourConnectorIsSet : null,
    neighbourConnection : null,
  }

  thisGraph.graphName = thisGraph.consts.UNTILTED_GRAPH_NAME;
  thisGraph.openedGraph = null;
  thisGraph.selectedGraphName = null;
  thisGraph.ldpGraphName = null;
  thisGraph.selectedLdpGraphName = null;
  thisGraph.typeLdpServer = "local"; //local or external, default : local
  thisGraph.mockData0 = null;
  thisGraph.listOfLocalGraphs = [];
  thisGraph.listOfExtenalGraphs = [];
  thisGraph.graphToDeleteName = null;
  thisGraph.firstBgElement = null;
  thisGraph.d3Data = {};
  thisGraph.d3Data.nodes = [];
  thisGraph.d3Data.edges = [];
  thisGraph.bgElement = null;
  thisGraph.svgNodesEnter = [];
  thisGraph.svgLinksEnter = [];
  thisGraph.svgLinksLabelEnter = [];
  thisGraph.diagonal = d3.svg.diagonal();
  thisGraph.panBoundary = 20; // Within 20px from edges will pan when dragging.
  thisGraph.panBgBoundaryRate = 10;
  thisGraph.panBgLRBoundary = thisGraph.svgContainer.width / thisGraph.panBgBoundaryRate;
  thisGraph.panBgUDRBoundary = thisGraph.svgContainer.height / thisGraph.panBgBoundaryRate;
  thisGraph.panTimer = null;
  thisGraph.panBgSpeed = 20;
  thisGraph.panSpeed = 50;
  thisGraph.zoomListener = null;
  thisGraph.translateX = null;
  thisGraph.translateY = null;

  // dbpedia : http://dbpedia.org/resource/ (John_Lennon)
  // thisGraph.rwwplayUri = "https://localhost:8443/2013/cartopair/";
  // thisGraph.rwwplayUri = "https://212.47.232.171:8443/2013/cartopair/";
  // thisGraph.semFormsUri = "http://localhost:9000/ldp/cartopair/";

  /**
   * URI of the External LDP Store currently used (should be in a config object ?)
   * @memberof FluidGraph
   */
  thisGraph.rwwplayUri = "https://ldp.virtual-assembly.org:8443/2013/cartopair/";

  /**
   * External LDP Store information stored as object
   * @memberof FluidGraph
   */
  thisGraph.externalStore = {
    uri : thisGraph.rwwplayUri,
    context : {
      "@context":{
        "loglink": "http://www.fluidlog.com/2013/05/loglink/core#",
        "nodes": "http://www.fluidlog.com/2013/05/loglink/core#node",
        "label": "http://www.w3.org/2000/01/rdf-schema#label",
        "index": "http://www.fluidlog.com/2013/05/loglink/core#index",
        "x": "http://www.fluidlog.com/2013/05/loglink/core#x",
        "y": "http://www.fluidlog.com/2013/05/loglink/core#y",
        "edges": "http://www.fluidlog.com/2013/05/loglink/core#edge",
        "source": "http://www.fluidlog.com/2013/05/loglink/core#source",
        "target": "http://www.fluidlog.com/2013/05/loglink/core#target",
        "hypertext": "http://www.fluidlog.com/2013/05/loglink/core#hypertext",
        "av": "http://www.assemblee-virtuelle.org/ontologies/v1.owl#",
        "foaf": "http://xmlns.com/foaf/0.1/"
      }
    }
  }
}

/**
 * Some constant defined to be used by the Graph instance
 * Come from : https://github.com/cjrd/directed-graph-creator/blob/master/graph-creator.js
 * @memberof FluidGraph
 */
FluidGraph.prototype.consts =  {
  selectedClass: "selected",
  connectClass: "connect-node",
  circleGClass: "conceptG",
  graphClass: "graph",
  BACKSPACE_KEY: 8,
  DELETE_KEY: 46,
  ENTER_KEY: 13,
  nodeRadius: 50,
  OPENED_GRAPH_KEY: "openedGraph",
  UNTILTED_GRAPH_NAME: "Untilted",
};


text:
<?php

namespace AuthBucket\Push\ServiceType;

use Authbucket\Push\Model\MessageInterface;
use Authbucket\Push\Model\ServiceInterface;

/**
 * Push service type handler interface.
 *
 * @author Wong Hoi Sing Edison <hswong3i@pantarei-design.com>
 */
interface ServiceTypeHandlerInterface
{
    public function send(ServiceInterface $service, MessageInterface $message);
}


text:
    <meta http-equiv="Content-Type" content="text/html; charset=Windows-1252" />
    <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5" />
    <title>About.txtProductName Field</title>
    <xml>
    </xml>
    <link rel="stylesheet" type="text/css" href="MSDN.css" />

            SQL Schema Tool Help

About.txtProductName Field

private TextBox txtProductName;

See Also

        About Class | Lewis.SST.Help Namespace

      <object type="application/x-oleobject" classid="clsid:1e2a7bd0-dab9-11d0-b93a-00c04fc99f9e" viewastext="true" style="display: none;">
        <param name="Keyword" value="txtProductName field">
        </param>
        <param name="Keyword" value="txtProductName field, About class">
        </param>
        <param name="Keyword" value="About.txtProductName field">
        </param>
      </object>

Generated from assembly SST [1.0.2793.35291]


text:
// Copyright 2019 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.

#include "content/renderer/accessibility/ax_image_annotator.h"

#include <ctype.h>
#include <utility>
#include <vector>

#include "base/base64.h"
#include "base/containers/contains.h"
#include "base/containers/fixed_flat_map.h"
#include "base/i18n/char_iterator.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"
#include "content/public/common/content_client.h"
#include "content/public/renderer/render_frame.h"
#include "content/renderer/accessibility/ax_image_stopwords.h"
#include "crypto/sha2.h"
#include "services/metrics/public/cpp/mojo_ukm_recorder.h"
#include "services/metrics/public/cpp/ukm_builders.h"
#include "third_party/blink/public/strings/grit/blink_accessibility_strings.h"
#include "third_party/blink/public/web/web_ax_object.h"
#include "third_party/blink/public/web/web_document.h"
#include "third_party/blink/public/web/web_element.h"
#include "third_party/blink/public/web/web_local_frame.h"
#include "third_party/blink/public/web/web_node.h"
#include "ui/accessibility/accessibility_features.h"
#include "ui/accessibility/ax_role_properties.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/transform.h"
#include "url/gurl.h"

namespace content {

namespace {

int GetMessageIdForIconEnum(const std::string& icon_type) {
  static constexpr auto kIconTypeToMessageIdMap =
      base::MakeFixedFlatMap<base::StringPiece, int>({
          {"ICON_PLUS", IDS_AX_IMAGE_ANNOTATION_ICON_PLUS},
          {"ICON_ARROW_BACKWARD", IDS_AX_IMAGE_ANNOTATION_ICON_ARROW_BACKWARD},
          {"ICON_ARROW_FORWARD", IDS_AX_IMAGE_ANNOTATION_ICON_ARROW_FORWARD},
          {"ICON_CALL", IDS_AX_IMAGE_ANNOTATION_ICON_CALL},
          {"ICON_CHAT", IDS_AX_IMAGE_ANNOTATION_ICON_CHAT},
          {"ICON_CHECK", IDS_AX_IMAGE_ANNOTATION_ICON_CHECK},
          {"ICON_X", IDS_AX_IMAGE_ANNOTATION_ICON_X},
          {"ICON_DELETE", IDS_AX_IMAGE_ANNOTATION_ICON_DELETE},
          {"ICON_EDIT", IDS_AX_IMAGE_ANNOTATION_ICON_EDIT},
          {"ICON_EMOJI", IDS_AX_IMAGE_ANNOTATION_ICON_EMOJI},
          {"ICON_END_CALL", IDS_AX_IMAGE_ANNOTATION_ICON_END_CALL},
          {"ICON_V_DOWNWARD", IDS_AX_IMAGE_ANNOTATION_ICON_V_DOWNWARD},
          {"ICON_HEART", IDS_AX_IMAGE_ANNOTATION_ICON_HEART},
          {"ICON_HOME", IDS_AX_IMAGE_ANNOTATION_ICON_HOME},
          {"ICON_INFO", IDS_AX_IMAGE_ANNOTATION_ICON_INFO},
          {"ICON_LAUNCH_APPS", IDS_AX_IMAGE_ANNOTATION_ICON_LAUNCH_APPS},
          {"ICON_THUMBS_UP", IDS_AX_IMAGE_ANNOTATION_ICON_THUMBS_UP},
          {"ICON_THREE_BARS", IDS_AX_IMAGE_ANNOTATION_ICON_THREE_BARS},
          {"ICON_THREE_DOTS", IDS_AX_IMAGE_ANNOTATION_ICON_THREE_DOTS},
          {"ICON_NOTIFICATIONS", IDS_AX_IMAGE_ANNOTATION_ICON_NOTIFICATIONS},
          {"ICON_PAUSE", IDS_AX_IMAGE_ANNOTATION_ICON_PAUSE},
          {"ICON_PLAY", IDS_AX_IMAGE_ANNOTATION_ICON_PLAY},
          {"ICON_REFRESH", IDS_AX_IMAGE_ANNOTATION_ICON_REFRESH},
          {"ICON_MAGNIFYING_GLASS",
           IDS_AX_IMAGE_ANNOTATION_ICON_MAGNIFYING_GLASS},
          {"ICON_SEND", IDS_AX_IMAGE_ANNOTATION_ICON_SEND},
          {"ICON_SETTINGS", IDS_AX_IMAGE_ANNOTATION_ICON_SETTINGS},
          {"ICON_SHARE", IDS_AX_IMAGE_ANNOTATION_ICON_SHARE},
          {"ICON_STAR", IDS_AX_IMAGE_ANNOTATION_ICON_STAR},
          {"ICON_TAKE_PHOTO", IDS_AX_IMAGE_ANNOTATION_ICON_TAKE_PHOTO},
          {"ICON_TIME", IDS_AX_IMAGE_ANNOTATION_ICON_TIME},
          {"ICON_VIDEOCAM", IDS_AX_IMAGE_ANNOTATION_ICON_VIDEOCAM},
          {"ICON_EXPAND", IDS_AX_IMAGE_ANNOTATION_ICON_EXPAND},
          {"ICON_CONTRACT", IDS_AX_IMAGE_ANNOTATION_ICON_CONTRACT},
          {"ICON_GOOGLE", IDS_AX_IMAGE_ANNOTATION_ICON_GOOGLE},
          {"ICON_TWITTER", IDS_AX_IMAGE_ANNOTATION_ICON_TWITTER},
          {"ICON_FACEBOOK", IDS_AX_IMAGE_ANNOTATION_ICON_FACEBOOK},
          {"ICON_ASSISTANT", IDS_AX_IMAGE_ANNOTATION_ICON_ASSISTANT},
          {"ICON_WEATHER", IDS_AX_IMAGE_ANNOTATION_ICON_WEATHER},
          {"ICON_SHOPPING_CART", IDS_AX_IMAGE_ANNOTATION_ICON_SHOPPING_CART},
          {"ICON_UPLOAD", IDS_AX_IMAGE_ANNOTATION_ICON_UPLOAD},
          {"ICON_QUESTION", IDS_AX_IMAGE_ANNOTATION_ICON_QUESTION},
          {"ICON_MIC", IDS_AX_IMAGE_ANNOTATION_ICON_MIC},
          {"ICON_MIC_MUTE", IDS_AX_IMAGE_ANNOTATION_ICON_MIC_MUTE},
          {"ICON_GALLERY", IDS_AX_IMAGE_ANNOTATION_ICON_GALLERY},
          {"ICON_COMPASS", IDS_AX_IMAGE_ANNOTATION_ICON_COMPASS},
          {"ICON_PEOPLE", IDS_AX_IMAGE_ANNOTATION_ICON_PEOPLE},
          {"ICON_ARROW_UPWARD", IDS_AX_IMAGE_ANNOTATION_ICON_ARROW_UPWARD},
          {"ICON_ENVELOPE", IDS_AX_IMAGE_ANNOTATION_ICON_ENVELOPE},
          {"ICON_EMOJI_FACE", IDS_AX_IMAGE_ANNOTATION_ICON_EMOJI_FACE},
          {"ICON_PAPERCLIP", IDS_AX_IMAGE_ANNOTATION_ICON_PAPERCLIP},
          {"ICON_CAST", IDS_AX_IMAGE_ANNOTATION_ICON_CAST},
          {"ICON_VOLUME_UP", IDS_AX_IMAGE_ANNOTATION_ICON_VOLUME_UP},
          {"ICON_VOLUME_DOWN", IDS_AX_IMAGE_ANNOTATION_ICON_VOLUME_DOWN},
          {"ICON_VOLUME_STATE", IDS_AX_IMAGE_ANNOTATION_ICON_VOLUME_STATE},
          {"ICON_VOLUME_MUTE", IDS_AX_IMAGE_ANNOTATION_ICON_VOLUME_MUTE},
          {"ICON_STOP", IDS_AX_IMAGE_ANNOTATION_ICON_STOP},
          {"ICON_SHOPPING_BAG", IDS_AX_IMAGE_ANNOTATION_ICON_SHOPPING_BAG},
          {"ICON_LIST", IDS_AX_IMAGE_ANNOTATION_ICON_LIST},
          {"ICON_LOCATION", IDS_AX_IMAGE_ANNOTATION_ICON_LOCATION},
          {"ICON_CALENDAR", IDS_AX_IMAGE_ANNOTATION_ICON_CALENDAR},
          {"ICON_THUMBS_DOWN", IDS_AX_IMAGE_ANNOTATION_ICON_THUMBS_DOWN},
          {"ICON_HEADSET", IDS_AX_IMAGE_ANNOTATION_ICON_HEADSET},
          {"ICON_REDO", IDS_AX_IMAGE_ANNOTATION_ICON_REDO},
          {"ICON_UNDO", IDS_AX_IMAGE_ANNOTATION_ICON_UNDO},
          {"ICON_DOWNLOAD", IDS_AX_IMAGE_ANNOTATION_ICON_DOWNLOAD},
          {"ICON_ARROW_DOWNWARD", IDS_AX_IMAGE_ANNOTATION_ICON_ARROW_DOWNWARD},
          {"ICON_V_UPWARD", IDS_AX_IMAGE_ANNOTATION_ICON_V_UPWARD},
          {"ICON_V_FORWARD", IDS_AX_IMAGE_ANNOTATION_ICON_V_FORWARD},
          {"ICON_V_BACKWARD", IDS_AX_IMAGE_ANNOTATION_ICON_V_BACKWARD},
          {"ICON_HISTORY", IDS_AX_IMAGE_ANNOTATION_ICON_HISTORY},
          {"ICON_PERSON", IDS_AX_IMAGE_ANNOTATION_ICON_PERSON},
          {"ICON_HAPPY_FACE", IDS_AX_IMAGE_ANNOTATION_ICON_HAPPY_FACE},
          {"ICON_SAD_FACE", IDS_AX_IMAGE_ANNOTATION_ICON_SAD_FACE},
          {"ICON_MOON", IDS_AX_IMAGE_ANNOTATION_ICON_MOON},
          {"ICON_CLOUD", IDS_AX_IMAGE_ANNOTATION_ICON_CLOUD},
          {"ICON_SUN", IDS_AX_IMAGE_ANNOTATION_ICON_SUN},
      });

  auto* iter = kIconTypeToMessageIdMap.find(icon_type);
  if (iter == kIconTypeToMessageIdMap.end())
    return 0;

  return iter->second;
}

}  // namespace

AXImageAnnotator::AXImageAnnotator(
    RenderAccessibilityImpl* const render_accessibility,
    mojo::PendingRemote<image_annotation::mojom::Annotator> annotator)
    : render_accessibility_(render_accessibility),
      annotator_(std::move(annotator)) {
  DCHECK(render_accessibility_);
}

AXImageAnnotator::~AXImageAnnotator() {}

void AXImageAnnotator::Destroy() {
  MarkAllImagesDirty();
}

std::string AXImageAnnotator::GetImageAnnotation(
    blink::WebAXObject& image) const {
  DCHECK(!image.IsDetached());
  const auto lookup = image_annotations_.find(image.AxID());
  if (lookup != image_annotations_.end())
    return lookup->second.annotation();
  return std::string();
}

ax::mojom::ImageAnnotationStatus AXImageAnnotator::GetImageAnnotationStatus(
    blink::WebAXObject& image) const {
  DCHECK(!image.IsDetached());
  const auto lookup = image_annotations_.find(image.AxID());
  if (lookup != image_annotations_.end())
    return lookup->second.status();
  return ax::mojom::ImageAnnotationStatus::kNone;
}

bool AXImageAnnotator::HasAnnotationInCache(blink::WebAXObject& image) const {
  DCHECK(!image.IsDetached());
  if (!HasImageInCache(image))
    return false;
  return image_annotations_.at(image.AxID()).HasAnnotation();
}

bool AXImageAnnotator::HasImageInCache(const blink::WebAXObject& image) const {
  DCHECK(!image.IsDetached());
  return base::Contains(image_annotations_, image.AxID());
}

void AXImageAnnotator::OnImageAdded(blink::WebAXObject& image) {
  DCHECK(!image.IsDetached());
  DCHECK(!base::Contains(image_annotations_, image.AxID()));
  const std::string image_id = GenerateImageSourceId(image);
  if (image_id.empty())
    return;

  image_annotations_.emplace(image.AxID(), image);
  ImageInfo& image_info = image_annotations_.at(image.AxID());
  // Fetch image annotation.
  annotator_->AnnotateImage(image_id, render_accessibility_->GetLanguage(),
                            image_info.GetImageProcessor(),
                            base::BindOnce(&AXImageAnnotator::OnImageAnnotated,
                                           weak_factory_.GetWeakPtr(), image));
  VLOG(1) << "Requesting annotation for " << image_id << " with language '"
          << render_accessibility_->GetLanguage() << "' from page "
          << GetDocumentUrl();
}

void AXImageAnnotator::OnImageUpdated(blink::WebAXObject& image) {
  DCHECK(!image.IsDetached());
  DCHECK(base::Contains(image_annotations_, image.AxID()));
  const std::string image_id = GenerateImageSourceId(image);
  if (image_id.empty())
    return;

  ImageInfo& image_info = image_annotations_.at(image.AxID());
  // Update annotation.
  annotator_->AnnotateImage(image_id, render_accessibility_->GetLanguage(),
                            image_info.GetImageProcessor(),
                            base::BindOnce(&AXImageAnnotator::OnImageAnnotated,
                                           weak_factory_.GetWeakPtr(), image));
}

void AXImageAnnotator::OnImageRemoved(blink::WebAXObject& image) {
  DCHECK(!image.IsDetached());
  auto lookup = image_annotations_.find(image.AxID());
  if (lookup == image_annotations_.end()) {
    NOTREACHED() << "Removing an image that has not been added.";
    return;
  }
  image_annotations_.erase(lookup);
}

// static
int AXImageAnnotator::GetLengthAfterRemovingStopwords(
    const std::string& image_name) {
  // Split the image name into words by splitting on all whitespace and
  // punctuation. Reject any words that are classified as stopwords.
  // Return the number of remaining codepoints.
  const char* separators = "0123456789`~!@#$%^&*()[]{}\\|;:'\",.<>?/-_=+ ";
  std::vector<std::string> words = base::SplitString(
      image_name, separators, base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
  int remaining_codepoints = 0;
  for (const std::string& word : words) {
    if (AXImageStopwords::GetInstance().IsImageStopword(word.c_str()))
      continue;

    for (base::i18n::UTF8CharIterator iter(word); !iter.end(); iter.Advance())
      remaining_codepoints++;
  }

  return remaining_codepoints;
}

// static
bool AXImageAnnotator::ImageNameHasMostlyStopwords(
    const std::string& image_name) {
  // Compute how many characters remain after removing stopwords.
  int remaining_codepoints = GetLengthAfterRemovingStopwords(image_name);

  // If there are 3 or fewer unicode codepoints remaining, classify
  // the string as "mostly stopwords".
  //
  // More details and analysis in this (Google-internal) design doc:
  // http://goto.google.com/augment-existing-image-descriptions
  return (remaining_codepoints <= 3);
}

#if defined(CONTENT_IMPLEMENTATION)
ContentClient* AXImageAnnotator::GetContentClient() const {
  return content::GetContentClient();
}
#else
ContentClient* AXImageAnnotator::GetContentClient() const {
  return nullptr;
}
#endif  // defined(CONTENT_IMPLEMENTATION)

std::string AXImageAnnotator::GenerateImageSourceId(
    const blink::WebAXObject& image) const {
  DCHECK(render_accessibility_);
  DCHECK(!image.IsDetached());
  const std::string document_url =
      render_accessibility_->GetMainDocument().Url().GetString().Utf8();
  const std::string image_src = image.Url().GetString().Utf8();
  if (document_url.empty() || image_src.empty())
    return std::string();

  // The |image_src| might be a URL that is relative to the document's URL.
  const GURL image_url = GURL(document_url).Resolve(image_src);
  if (!image_url.is_valid())
    return std::string();

  // If |image_url| appears to be publicly reachable, return the URL as the
  // image source ID.
  if (image_url.SchemeIsHTTPOrHTTPS())
    return image_url.spec();

  // If |image_url| is not publicly reachable, return a hash of |image_url|.
  // Scheme could be "data", "javascript", "ftp", "file", etc.
  const std::string& content = image_url.GetContent();
  if (content.empty())
    return std::string();
  std::string source_id;
  base::Base64Encode(crypto::SHA256HashString(content), &source_id);
  return source_id;
}

void AXImageAnnotator::MarkAllImagesDirty() {
  for (auto& key_value : image_annotations_) {
    blink::WebAXObject image = blink::WebAXObject::FromWebDocumentByID(
        render_accessibility_->GetMainDocument(), key_value.first);
    if (!image.IsDetached())
      MarkDirty(image);
  }
  image_annotations_.clear();
}

void AXImageAnnotator::MarkDirty(const blink::WebAXObject& image) const {
  render_accessibility_->MarkWebAXObjectDirty(image, false /* subtree */);

  // Check two unignored parents. If either of them is a link or root web area,
  // mark it dirty too, because we want a link or document containing exactly
  // a single image and nothing more to get annotated directly, too.
  //
  // TODO(dmazzoni): Expose ParentObjectUnignored in WebAXObject to
  // make this simpler.
  blink::WebAXObject parent = image.ParentObject();
  for (int ancestor_count = 0; !parent.IsDetached() && ancestor_count < 2;
       parent = parent.ParentObject()) {
    if (!parent.AccessibilityIsIgnored()) {
      ++ancestor_count;
      if (ui::IsLink(parent.Role()) || ui::IsPlatformDocument(parent.Role())) {
        render_accessibility_->MarkWebAXObjectDirty(parent,
                                                    false /* subtree */);
        return;
      }
    }
  }
}

AXImageAnnotator::ImageInfo::ImageInfo(const blink::WebAXObject& image)
    : image_processor_(
          base::BindRepeating(&AXImageAnnotator::GetImageData, image)),
      status_(ax::mojom::ImageAnnotationStatus::kAnnotationPending),
      annotation_(absl::nullopt) {}

AXImageAnnotator::ImageInfo::~ImageInfo() = default;

mojo::PendingRemote<image_annotation::mojom::ImageProcessor>
AXImageAnnotator::ImageInfo::GetImageProcessor() {
  return image_processor_.GetPendingRemote();
}

bool AXImageAnnotator::ImageInfo::HasAnnotation() const {
  switch (status_) {
    case ax::mojom::ImageAnnotationStatus::kNone:
    case ax::mojom::ImageAnnotationStatus::kWillNotAnnotateDueToScheme:
    case ax::mojom::ImageAnnotationStatus::kIneligibleForAnnotation:
    // The user hasn't requested an annotation yet, or a previously pending
    // annotation request had been cancelled.
    case ax::mojom::ImageAnnotationStatus::kEligibleForAnnotation:
    case ax::mojom::ImageAnnotationStatus::kSilentlyEligibleForAnnotation:
    case ax::mojom::ImageAnnotationStatus::kAnnotationPending:
      return false;
    case ax::mojom::ImageAnnotationStatus::kAnnotationSucceeded:
      DCHECK(annotation_.has_value());
      return true;
    case ax::mojom::ImageAnnotationStatus::kAnnotationEmpty:
    // Image has been classified as adult content.
    case ax::mojom::ImageAnnotationStatus::kAnnotationAdult:
    case ax::mojom::ImageAnnotationStatus::kAnnotationProcessFailed:
      DCHECK(!annotation_.has_value());
      return true;
  }
}

// static
SkBitmap AXImageAnnotator::GetImageData(const blink::WebAXObject& image) {
  if (image.IsDetached())
    return SkBitmap();
  blink::WebNode node = image.GetNode();
  if (node.IsNull() || !node.IsElementNode())
    return SkBitmap();
  blink::WebElement element = node.To<blink::WebElement>();
  VLOG(1) << "Uploading pixels for " << element.ImageContents().width() << " x "
          << element.ImageContents().height() << " image";
  return element.ImageContents();
}

void AXImageAnnotator::OnImageAnnotated(
    const blink::WebAXObject& image,
    image_annotation::mojom::AnnotateImageResultPtr result) {
  if (!blink::WebAXObject::MaybeUpdateLayoutAndCheckValidity(
          image.GetDocument())) {
    return;
  }

  if (!base::Contains(image_annotations_, image.AxID()))
    return;

  if (image.IsDetached()) {
    image_annotations_.at(image.AxID())
        .set_status(ax::mojom::ImageAnnotationStatus::kIneligibleForAnnotation);
    // We should not mark dirty a detached object.
    return;
  }

  if (features::IsAugmentExistingImageLabelsEnabled()) {
    // Get the image size as minimum and maximum dimension.
    blink::WebAXObject offset_container;
    gfx::RectF bounds;
    gfx::Transform container_transform;
    bool clips_children = false;
    image.GetRelativeBounds(offset_container, bounds, container_transform,
                            &clips_children);
    int min_dimension =
        static_cast<int>(std::min(bounds.width(), bounds.height()));
    int max_dimension =
        static_cast<int>(std::max(bounds.width(), bounds.height()));

    // Collect some histograms on the number of characters in the
    // image name, and also the image name after removing stopwords,
    // and also the minimum and maximum dimension,
    // as a function of whether the retrieved image label was
    // a success, an error, or empty.
    ax::mojom::NameFrom name_from;
    blink::WebVector<blink::WebAXObject> name_objects;
    blink::WebString web_name = image.GetName(name_from, name_objects);
    int non_stop_length = GetLengthAfterRemovingStopwords(web_name.Utf8());

    if (result->is_error_code()) {
      base::UmaHistogramCounts100("Accessibility.ImageLabels.ErrorByNameLength",
                                  web_name.length());
      base::UmaHistogramCounts100(
          "Accessibility.ImageLabels.ErrorByNonStopNameLength",
          non_stop_length);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.ErrorByMaxDimension", max_dimension);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.ErrorByMinDimension", min_dimension);
    } else if (!result->is_annotations()) {
      base::UmaHistogramCounts100("Accessibility.ImageLabels.EmptyByNameLength",
                                  web_name.length());
      base::UmaHistogramCounts100(
          "Accessibility.ImageLabels.EmptyByNonStopNameLength",
          non_stop_length);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.EmptyByMaxDimension", max_dimension);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.EmptyByMinDimension", min_dimension);
    } else {
      base::UmaHistogramCounts100(
          "Accessibility.ImageLabels.SuccessByNameLength", web_name.length());
      base::UmaHistogramCounts100(
          "Accessibility.ImageLabels.SuccessByNonStopNameLength",
          non_stop_length);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.SuccessByMaxDimension", max_dimension);
      base::UmaHistogramCounts1000(
          "Accessibility.ImageLabels.SuccessByMinDimension", min_dimension);
    }
  }

  if (result->is_error_code()) {
    DLOG(WARNING) << "Image annotation error.";
    switch (result->get_error_code()) {
      case image_annotation::mojom::AnnotateImageError::kCanceled:
        // By marking the image as having an annotation status of
        // kSilentlyEligibleForAnnotation and not one of
        // kEligibleForAnnotation:, the user will not be asked to visit the
        // context menu to turn on automatic image labels, because there is no
        // way to repeat the operation from that menu yet.
        image_annotations_.at(image.AxID())
            .set_status(ax::mojom::ImageAnnotationStatus::
                            kSilentlyEligibleForAnnotation);
        break;
      case image_annotation::mojom::AnnotateImageError::kFailure:
        image_annotations_.at(image.AxID())
            .set_status(
                ax::mojom::ImageAnnotationStatus::kAnnotationProcessFailed);
        break;
      case image_annotation::mojom::AnnotateImageError::kAdult:
        image_annotations_.at(image.AxID())
            .set_status(ax::mojom::ImageAnnotationStatus::kAnnotationAdult);
        break;
    }
    MarkDirty(image);
    return;
  }

  if (!result->is_annotations()) {
    DLOG(WARNING) << "No image annotation results.";
    image_annotations_.at(image.AxID())
        .set_status(ax::mojom::ImageAnnotationStatus::kAnnotationEmpty);
    MarkDirty(image);
    return;
  }

  bool has_ocr = false;
  bool has_description = false;
  std::vector<std::string> contextualized_strings;
  for (const mojo::InlinedStructPtr<image_annotation::mojom::Annotation>&
           annotation : result->get_annotations()) {
    int message_id = 0;
    switch (annotation->type) {
      case image_annotation::mojom::AnnotationType::kOcr:
        has_ocr = true;
        message_id = IDS_AX_IMAGE_ANNOTATION_OCR_CONTEXT;
        break;
      case image_annotation::mojom::AnnotationType::kCaption:
      case image_annotation::mojom::AnnotationType::kLabel:
        has_description = true;
        message_id = IDS_AX_IMAGE_ANNOTATION_DESCRIPTION_CONTEXT;
        break;
      case image_annotation::mojom::AnnotationType::kIcon: {
        int icon_message_id = GetMessageIdForIconEnum(annotation->text);

        DCHECK(GetContentClient());
        contextualized_strings.push_back(base::UTF16ToUTF8(
            GetContentClient()->GetLocalizedString(icon_message_id)));
        break;
      }
    }

    // Skip unrecognized annotation types.
    if (message_id == 0)
      continue;

    int last_meaningful_char = annotation->text.length() - 1;
    while (last_meaningful_char >= 0) {
      bool is_whitespace_or_punct =
          isspace(annotation->text[last_meaningful_char]) ||
          ispunct(annotation->text[last_meaningful_char]);
      if (!is_whitespace_or_punct)
        break;
      last_meaningful_char--;
    }

    if (annotation->text.empty() || last_meaningful_char < 0)
      continue;

    std::string text = annotation->text.substr(0, last_meaningful_char + 1);
    if (GetContentClient()) {
      contextualized_strings.push_back(
          base::UTF16ToUTF8(GetContentClient()->GetLocalizedString(
              message_id, base::UTF8ToUTF16(text))));
    } else {
      contextualized_strings.push_back(text);
    }
  }

  if (contextualized_strings.empty()) {
    image_annotations_.at(image.AxID())
        .set_status(ax::mojom::ImageAnnotationStatus::kAnnotationEmpty);
    MarkDirty(image);
    return;
  }

  ax::mojom::NameFrom name_from;
  blink::WebVector<blink::WebAXObject> name_objects;
  blink::WebString name = image.GetName(name_from, name_objects);
  bool has_existing_label = !name.IsEmpty();

  ukm::builders::Accessibility_ImageDescriptions(
      render_accessibility_->GetMainDocument().GetUkmSourceId())
      .SetOCR(has_ocr)
      .SetDescription(has_description)
      .SetImageAlreadyHasLabel(has_existing_label)
      .Record(render_accessibility_->ukm_recorder());

  image_annotations_.at(image.AxID())
      .set_status(ax::mojom::ImageAnnotationStatus::kAnnotationSucceeded);
  // TODO(accessibility): join two sentences together in a more i18n-friendly
  // way. Since this is intended for a screen reader, though, a period
  // probably works in almost all languages.
  std::string contextualized_string =
      base::JoinString(contextualized_strings, ". ");
  image_annotations_.at(image.AxID()).set_annotation(contextualized_string);
  MarkDirty(image);

  VLOG(1) << "Annotating image on page " << GetDocumentUrl() << " - "
          << contextualized_string;
}

std::string AXImageAnnotator::GetDocumentUrl() const {
  const blink::WebLocalFrame* frame =
      render_accessibility_->render_frame()->GetWebFrame();
  return frame->GetDocument().Url().GetString().Utf8();
}

}  // namespace content


text:
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
 * The length property of parseFloat is 1
 *
 * @path ch15/15.1/15.1.2/15.1.2.3/S15.1.2.3_A7.4.js
 * @description parseFloat.length === 1
 */

//CHECK#1
if (parseFloat.length !== 1) {
  $ERROR('#1: parseFloat.length === 1. Actual: ' + (parseFloat.length));
}


text:
description: Add a new task to an existing GoCD job
keywords: GoCD configuration, job, jobs, task, continuous delivery pipeline, CD pipeline
title: Add task to Existing Job
---

# Add a new task to an existing GoCD Job

Now that we have a pipeline with stage(s) containing job(s) we can add tasks to any of the existing jobs. You can now use the tree navigation on the left side of the screen to edit a job under a stage.

- Click on the job name that you want to edit on the tree as shown below. The "defaultJob" is being edited.
![](../images/edit_job_link_on_tree.png)
- Click on "Add new task". You can choose the task type from Ant, Nant, Rake and Fetch Artifact. Or you can choose "More..." to choose a command from [command repository](../advanced_usage/command_repository.html) or specify your own command
![](../images/add_new_task_link.png)
- Fill the basic settings for the task
- Click on help icon next to the fields to get additional details about the fields you are editing.
- Click "Save"
![](../images/add_new_task_window.png)
- Advanced Options section allows you to specify a Task in which you can provide the actions (typically clean up) that needs to be taken when users chooses to cancel the stage.
![](../images/add_on_cancel_task.png)


text:
module PixiClient
  module Requests
    class ReadOrderlines < Base
      attr_accessor :message

      # Pixi* documentation says that the pixi order number
      # is mandatory for this requests
      def initialize(message)
        self.message = message
      end

      def api_method
        :pixi_read_orderlines
      end

    end
  end
end


text:
package skin.support.widget;

import android.content.Context;
import android.support.v7.widget.AppCompatRatingBar;
import android.util.AttributeSet;

import skin.support.R;

/**
 * Created by ximsfei on 17-1-21.
 */

public class SkinCompatRatingBar extends AppCompatRatingBar implements SkinCompatSupportable {
    private final SkinCompatProgressBarHelper mSkinCompatProgressBarHelper;

    public SkinCompatRatingBar(Context context) {
        this(context, null);
    }

    public SkinCompatRatingBar(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.ratingBarStyle);
    }

    public SkinCompatRatingBar(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);

        mSkinCompatProgressBarHelper = new SkinCompatProgressBarHelper(this);
        mSkinCompatProgressBarHelper.loadFromAttributes(attrs, defStyleAttr);
    }

    @Override
    public void applySkin() {
        if (mSkinCompatProgressBarHelper != null) {
            mSkinCompatProgressBarHelper.applySkin();
        }
    }
}


text:
package com.migibert.kheo.util;

import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.migibert.kheo.core.Server;

public class ServerPropertyMetadataFilter {

    public static JsonNode filter(Server server) {

        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonValue = mapper.writeValueAsString(server);
            JsonNode rootNode = mapper.readTree(jsonValue);
            JsonNode properties = rootNode.get("serverProperties");
            Iterator<JsonNode> iterator = properties.elements();
            while (iterator.hasNext()) {
                ObjectNode property = (ObjectNode) iterator.next();
                property.remove("@kheo-class");
            }
            return rootNode;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

}


text:
<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision: 297028 $ -->
<!-- Generated by xml_proto.php v2.2. Found in /scripts directory of phpdoc. -->
<refentry xml:id="function.db2-result" xmlns="http://docbook.org/ns/docbook">
 <refnamediv>
  <refname>db2_result</refname>
  <refpurpose>
   Returns a single column from a row in the result set
  </refpurpose>
 </refnamediv>
 <refsect1 role="description">
  &reftitle.description;
  <methodsynopsis>
   <type>mixed</type><methodname>db2_result</methodname>
   <methodparam><type>resource</type><parameter>stmt</parameter></methodparam>
   <methodparam><type>mixed</type><parameter>column</parameter></methodparam>
  </methodsynopsis>

  <para>
   Use <function>db2_result</function> to return the value of a specified
   column in the current row of a result set. You must call
   <function>db2_fetch_row</function> before calling
   <function>db2_result</function> to set the location of the result set
   pointer.
  </para>

 </refsect1>
 <refsect1 role="parameters">
  &reftitle.parameters;
  <para>
   <variablelist>
    <varlistentry>
     <term><parameter>stmt</parameter></term>
      <listitem>
       <para>
        A valid <literal>stmt</literal> resource.
       </para>
      </listitem>
     </varlistentry>
    <varlistentry>
     <term><parameter>column</parameter></term>
      <listitem>
       <para>
        Either an integer mapping to the 0-indexed field in the result set, or
        a string matching the name of the column.
       </para>
      </listitem>
     </varlistentry>
   </variablelist>
  </para>
 </refsect1>
 <refsect1 role="returnvalues">
  &reftitle.returnvalues;
  <para>
   Returns the value of the requested field if the field exists in the result
   set. Returns NULL if the field does not exist, and issues a warning.
  </para>
 </refsect1>

 <refsect1 role="examples">
  &reftitle.examples;
  <para>
   <example>
    <title>A <function>db2_result</function> example</title>
    <para>
     The following example demonstrates how to iterate through a result set
     with <function>db2_fetch_row</function> and retrieve columns from the
     result set with <function>db2_result</function>.
    </para>
    <programlisting role="php">
<![CDATA[
<?php
$sql = 'SELECT name, breed FROM animals WHERE weight < ?';
$stmt = db2_prepare($conn, $sql);
db2_execute($stmt, array(10));
while (db2_fetch_row($stmt)) {
    $name = db2_result($stmt, 0);
    $breed = db2_result($stmt, 'BREED');
    print "$name $breed";
}
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
cat Pook
gold fish Bubbles
budgerigar Gizmo
goat Rickety Ride
]]>
    </screen>
   </example>
  </para>
 </refsect1>

 <refsect1 role="seealso">
  &reftitle.seealso;
  <para>
   <simplelist>
    <member><function>db2_fetch_array</function></member>
    <member><function>db2_fetch_assoc</function></member>
    <member><function>db2_fetch_both</function></member>
    <member><function>db2_fetch_object</function></member>
    <member><function>db2_fetch_row</function></member>
   </simplelist>
  </para>
 </refsect1>

</refentry>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->


text:
require 'conference_track_manager.rb'

describe ConferenceTrackManager do
  before do
    @manager = ConferenceTrackManager.new
    @manager.add_talks("Writing Fast Tests Against Enterprise Rails 60min\n"+
    "Overdoing it in Python 45min\n"+
    "Lua for the Masses 30min\n"+
    "Ruby Errors from Mismatched Gem Versions 45min\n"+
    "Common Ruby Errors 45min\n"+
    "Rails for Python Developers lightning\n"+
    "Communicating Over Distance 60min\n"+
    "Accounting-Driven Development 45min\n"+
    "Woah 30min\n"+
    "Sit Down and Write 30min\n"+
    "Pair Programming vs Noise 45min\n"+
    "Rails Magic 60min\n"+
    "Ruby on Rails: Why We Should Move On 60min\n"+
    "Clojure Ate Scala (on my project) 45min\n"+
    "Programming in the Boondocks of Seattle 30min\n"+
    "Ruby vs. Clojure for Back-End Development 30min\n"+
    "Ruby on Rails Legacy App Maintenance 60min\n"+
    "A World Without HackerNews 30min\n"+
    "User Interface CSS in Rails Apps 30min")
  end

  it 'finds the total time for all the talks' do
    @manager.total_time.should == 785
  end

  it 'determines the number of tracks needed' do
    @manager.tracks.count.should == 2
  end

  describe "conflict" do
    it "doesn't occur with lunch" do
      @manager.tracks.each do |track|
        noon = Time.new(track.talks.first.time.year, track.talks.first.time.month, track.talks.first.time.day, 12, 0)
        one = noon + 60*60
        talks_between_noon_and_one = track.talks.select do |talk|
          (talk.time >= noon && talk.time < one) ||
          (talk.time + talk.duration*60 > noon && talk.time + talk.duration*60 < one)
        end
        talks_between_noon_and_one.count.should == 1
        talks_between_noon_and_one.first.title.should == "Lunch"
        talks_between_noon_and_one.first.time.should == noon
        talks_between_noon_and_one.first.duration.should == 60
      end
    end

    describe "with networking event" do
      before do
        @last_talk_per_track = @manager.tracks.map do |track|
          track.talks.last
        end
      end

      it "has correct title and start time between 4pm and 5pm" do
        date = @last_talk_per_track.first.time
        four = Time.new(date.year, date.month, date.day, 16, 0)
        five = four + 60*60
        @last_talk_per_track.each do |networking_event|
          (networking_event.time >= four).should == true
          (networking_event.time <= five).should == true
          networking_event.title.should == "Networking Event"
        end
      end

      it "doesn't occur with other talks" do
        @manager.tracks.each do |track|
          networking_event_start_time = track.talks.last.time
          talks_between = track.talks.select do |talk|
            (talk.time >= networking_event_start_time) ||
            (talk.time + talk.duration*60 > networking_event_start_time)
          end
          talks_between.count.should == 1
          talks_between.first.title.should == "Networking Event"
        end
      end
    end
  end

  it "has no gaps or overlaps between talks" do
    @manager.tracks.each do |track|
      for i in 0..track.talks.count-2
        track.talks[i+1].time.should == track.talks[i].time + track.talks[i].duration*60
      end
    end
  end

  it "accurately displays the schedule as a string" do
    @manager.to_s =~ /\A((Track \d:\n)(((\d{2}:\d{2}(A|P)M)(\s|\w|[:().-])+)+(\n)?)+)+(\n)?\z/ #This is so gross
    $1.should == @manager.to_s
  end
end


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ MIT License
  ~
  ~ Copyright (c) 2016 Hossain Khan
  ~
  ~ Permission is hereby granted, free of charge, to any person obtaining a copy
  ~ of this software and associated documentation files (the "Software"), to deal
  ~ in the Software without restriction, including without limitation the rights
  ~ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  ~ copies of the Software, and to permit persons to whom the Software is
  ~ furnished to do so, subject to the following conditions:
  ~
  ~ The above copyright notice and this permission notice shall be included in all
  ~ copies or substantial portions of the Software.
  ~
  ~ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  ~ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  ~ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  ~ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  ~ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  ~ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  ~ SOFTWARE.
  -->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              xmlns:tools="http://schemas.android.com/tools"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
              android:orientation="vertical">

    <TextView
        android:id="@+id/primary_text"
        style="@style/DetailsContentTitle"
        tools:text="News Headline Title Text"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="14dp"
        android:gravity="center_vertical"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/secondary_text_first"
            style="@style/DetailsContentDescriptionSubtitle"
            tools:text="Category Name"/>

        <TextView
            android:id="@+id/secondary_text_second"
            style="@style/DetailsContentDescriptionSubtitle"
            tools:text="DateTime: July 17, 2017"/>

    </LinearLayout>

    <TextView
        android:id="@+id/extra_text"
        style="@style/DetailsContentDescription"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        tools:text="Filmmaker Guillermo del Toro teas up with Legendary Pictures to bring audiences a unique take on the monster film with this sci/fi production."/>

    <!--
        Placeholder for news source logo.
    -->
    <ImageView
        android:id="@+id/headlines_source_image"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="right"
        android:layout_marginTop="16dp"
        android:contentDescription="@string/content_description_news_source"
        android:visibility="gone"
        tools:src="@mipmap/ic_launcher"
        tools:visibility="visible"
        tools:ignore="RtlHardcoded"/>
</LinearLayout>


text:
``libweasyl.models.site``
=========================

.. automodule:: libweasyl.models.site
   :members:


text:
// Copyright (c) 2014 SIL International
// This software is licensed under the MIT License (http://opensource.org/licenses/MIT)
using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace Palaso.UI.WindowsForms.HtmlBrowser
{
	public interface IWebBrowserCallbacks
	{
		void OnCanGoBackChanged(EventArgs e);
		void OnCanGoForwardChanged(EventArgs e);
		void OnDocumentCompleted(WebBrowserDocumentCompletedEventArgs e);
		void OnDocumentTitleChanged(EventArgs e);
		void OnNavigated(WebBrowserNavigatedEventArgs e);
		void OnNavigating(WebBrowserNavigatingEventArgs e);
		void OnNewWindow(CancelEventArgs e);
		void OnProgressChanged(WebBrowserProgressChangedEventArgs e);
		void OnStatusTextChanged(EventArgs e);
	}
}


text:
<?php

namespace PhpEws\DataType;

use PhpEws\DataType;

/**
 * Definition of the NonEmptyArrayOfGroupIdentifiersType type
 */
class NonEmptyArrayOfGroupIdentifiersType extends DataType
{
    /**
     * GroupIdentifier property
     *
     * @var SidAndAttributesType
     */
    public $GroupIdentifier;
}


text:
/*function testIE() {
    var exp = new RegExp("Microsoft");
    if (exp.test(navigator.appName)){
        alert("IE");
        document.body.innerHTML="Non compatible avec Internet Explorer";
        document.getElementsByTagName("body").innerHTML="Non compatible avec Internet Explorer";

    }
}*/

function displayAndHide(div){
	document.getElementById(div).style.display = document.getElementById(div).style.display == "none" ? "block" : "none";
}

function display(div){
	document.getElementById(div).style.display = document.getElementById(div).style.display == "none" ? "block" : "block";
}