text:
var d3Edge = {};

//Define our data manager module.
d3Edge.dataManager = function module() {
  var exports = {},
    dispatch = d3.dispatch('geoReady', 'dataReady', 'dataLoading'),
    data,
    //Instantiate a new Crossfilter.
    transitCrossfilter = crossfilter(),
    //Define a location variable for our location dimension.
    location;

  //Create a method to load the csv file, and apply cleaning function asynchronously.
  exports.loadCsvData = function(_file, _cleaningFunc) {

    //Create the csv request using d3.csv.
    var loadCsv = d3.csv(_file);

    //On the progress event, dispatch the custom dataLoading event.
    loadCsv.on('progress', function() { dispatch.dataLoading(d3.event.loaded);});

    loadCsv.get(function (_err, _response) {
      //Apply the cleaning function supplied in the _cleaningFunc parameter.
      _response.forEach(function (d) {
        _cleaningFunc(d);
      });
      //Assign the cleaned response to our data variable.
      data = _response;

      //Add data to our Crossfilter.
      transitCrossfilter.add(_response);

      //Setup the location dimension.
      location = transitCrossfilter.dimension(function (d) {return d.LOCATION;});

      //Dispatch our custom dataReady event passing in the cleaned data.
      dispatch.dataReady(_response);
    });
  };
  //Create a method to access the cleaned data.
  exports.getCleanedData = function () {
    return data;
  };

  //Create a method to load the geojson file, and execute a custom callback on response.
  exports.loadGeoJson = function(_file, _callback) {
    //Load json file using d3.json.
    d3.json(_file, function (_err, _data) {
      //Execute the callback, assign the data to the context.
      _callback(_data);
    });
  };

  //Create a convienence method to get the size of our Crossfilter
  exports.getCrossfilterSize = function () {
    return transitCrossfilter.size();
  };

  //Create a filterLocation method to filter stop data by location area.
  exports.filterLocation = function (_locationArea) {
        //Get the longitudes of our bounding box, and contruct an array from them.
    var longitudes = [_locationArea[0][0], _locationArea[1][0]],
        //Get the latitudes of our bounding box, and construct an array from them.
        latitudes = [_locationArea[0][1], _locationArea[1][1]];

    location.filterFunction(function (d) {
      return d[0] >= longitudes[0] &&
      d[0] <= longitudes[1] &&
      d[1] >= latitudes[0] &&
      d[1] <= latitudes[1];
    });
    //Return all records within our boundin box.
    return location.top(Infinity);
  };

  //Create a getDelays method to filter and aggregate the delay data by stop.
  exports.getDelays = function (_locations) {
    var delayCrossfilter = crossfilter(),
        //Create a dimension by hour of the scheduled stop time.
        stopTime = delayCrossfilter.dimension(function (d) {return d.SCHEDULED.getHours();});

        //Group the dimension by hour, and reduce it by increasing the count for all delays greater than 1.
        lateArrivalsByStopTime = stopTime.group().reduce(
          function reduceAdd(p,v) {return v.DELAY > 0 ? p+1 : p+0;},
          function reduceRemove(p,v) {return 0;},
          function reduceInitial(p,v) {return 0;}
        );

    //Add our filtered locations to the crossfilter.
    delayCrossfilter.add(_locations);

    //Return an array contained the aggregated data, and the stopTime dimension.
    return [stopTime, lateArrivalsByStopTime];
  };

  d3.rebind(exports, dispatch, 'on');

  return exports;
};

//Define our map module.
d3Edge.map = function module() {
  //Create our custom events, and variables.
  var dispatch = d3.dispatch('hover', 'stopsEnd', 'routesEnd', 'brushing'),
    projection, path, t, s, svg, center, scale, size, brush, x1, x2, y1, y2, brushX, brushY;

  //Create and exports function that can be invoked on a selection.
  function exports(_selection) {

      //Set svg equal to the selection that invokes this module.
      svg = svg || _selection;

      //Bind an empty datum to the selection. Usefull later for zooming.
      svg.datum([]);

      //Set the projection up using our scale, center, and size parameters.
      projection = projection || d3.geo.mercator()
        .scale(scale)
        .center(center)
        .translate([size[0]/2, size[1]/2]);

      //Set the path up using our projection definied above.
      path = path || d3.geo.path()
        .projection(projection);

      //Get the longitude of the top left corner of our map area.
      long1 = projection.invert([0,0])[0];
      //Get the longitude of the top right corner of our map area.
      long2 = projection.invert([width, 0])[0];

      //Get the latitude of the top left corner of our map area.
      lat1 = projection.invert([0,0])[1];
      //Get the latitude of the bottom left corner of our map area.
      lat2 = projection.invert([width, height])[1];

      //Create a linear scale generator for the x of our brush.
      brushX = d3.scale.linear()
        .range([0, size[0]])
        .domain([long1,long2]);

      //Create a linear scale generator for the y of our brush.
      brushY = d3.scale.linear()
        .range([0, size[1]])
        .domain([lat1, lat2]);

      //Create our brush using our brushX and brushY scales.
      brush = d3.svg.brush()
        .x(brushX)
        .y(brushY)
        .on('brush', function () {dispatch.brushing(brush);});
  }

  //Create a center method to serve as both a getter, and a setter.
  exports.center = function(_coords) {
    if (!arguments.length) return center;
    center = _coords;
    return this;
  };

  //Create a scale method to serve as both a getter, and a setter.
  exports.scale = function(_scale) {
    if (!arguments.length) return scale;
    scale = _scale;
    return this;
  };

  //Create a size method to serve as both a getter and setter.
  exports.size = function(_size) {
    if (!arguments.length) return size;
    size = _size;
    return this;
  };

  //Create a drawRoutes method that can be invoked to create routes for each city.
  exports.drawRoutes = function(_data) {
    svg.append('path')
      .attr('class', 'route')
      .datum(topojson.object(_data, _data.objects.routes))
      .attr('d', function(d, i){return path(d, i);});

    //Dispatch our routesEnd event so we know with the routes visualization is complete.
    dispatch.routesEnd();
  };

  exports.drawStops = function(_data) {
    svg.selectAll('.stop')
      .data( _data.features)
      .enter().append('circle')
      .attr('cx', function (d) {return projection(d.geometry.coordinates)[0];})
      .attr('cy', function (d) {return projection(d.geometry.coordinates)[1];})
      .attr('r', 2)
      .attr('class', 'stop')
      .on('mouseover', dispatch.hover);
  };

  //Create our addBrush method.
  exports.addBrush = function () {
    svg.append('g')
      .attr('class', 'brush')
      .call(brush)
      .selectAll('rect')
      .attr('width', width);

    return this;
  };

  //Dispatch our stopsEnd event so we know with the stops visualization is complete.
  dispatch.stopsEnd();

  //Bind our custom events to the 'on' method of our function.
  d3.rebind(exports, dispatch, 'on');

  return exports;
};

d3Edge.radialHistogram = function module () {
  var slices = 24, //24 hours in a day.
    innerRadius = 100, //Default inner radius
    outerRadius = 300, //Default outer radius
    innerScale = d3.scale.linear(), //Define a scale for sizes segments based on value.
    group, //Our empty group variable
    dimension, //Our empty dimension variable.
    offset = 50, //Label offset value.
    lowerColor, //The color used for the minimum of our range
    upperColor, //The color used for the maximum of our range
    innerRange, //The lower bound for radius value
    outerRange, //The upper bound for radius value
    color = d3.scale.linear(); //Linear color scale used for the segments.

  //The chart function our module will return with the selection that called it,
  // as the only argument.
  function chart (_selection) {

    //If the innerRange is not defined, it equals the innerRadius.
    innerRange = innerRange ? innerRange : innerRadius;
    //If the outerRange is not defined, it equals the outerRadius.
    outerRange = outerRange ? outerRange : outerRadius;

    //Our d3 arc generator for the segments.
    var arc = d3.svg.arc()
      .innerRadius(function (d, i) {return innerScale(d);})
      .outerRadius(function (d, i) {return outerRadius;})
      .startAngle(function (d, i) {return 2 * Math.PI * (i/slices);})
      .endAngle(function (d, i) {return 2 * Math.PI * ((i+1)/slices);});

    //Our d3 arc generator for the labels.
    var label = d3.svg.arc()
      .innerRadius(outerRadius + offset)
      .outerRadius(outerRadius + offset)
      .startAngle(function (d, i) {return 2 * Math.PI * (i/slices);})
      .endAngle(function (d, i) {return 2 * Math.PI * ((i+1)/slices);});

    //The total number of records for the city
    var totalRecords = dimension.group().all(),
        //The total number of delays for they city.
        totalDelays = group.all();

        //Obtain the min and max for both totalRecords and totalDelays.
        // if there are no records, set to zero.
    var mintotalRecords = totalRecords.length ? +totalRecords[0].key : 0,
        maxtotalRecords = totalRecords.length ? +totalRecords[totalRecords.length-1].key : 0,
        mintotalDelays = totalDelays.length ? +totalDelays[0].key : 0,
        maxtotalDelays = totalDelays.length ? +totalDelays[totalDelays.length-1].key : 0;

    //We must always have an array of length 24. Inspect the totalRecords array,
    // and totalDelays array and splice to the beginning and end as required.
    for (i=0; i<mintotalRecords; i++) {
      totalRecords.splice(i, 0, {key:i, value:0});
    }

    for(i=maxtotalRecords; i<24; i++){
      totalRecords.splice(i, 0, {key:i, value:0});
    }

    for (i=0; i<mintotalDelays; i++) {
      totalDelays.splice(i, 0, {key:i, value:0});
    }

    for(i=maxtotalDelays; i<24; i++){
      totalDelays.splice(i, 0, {key:i, value:0});
    }

    //Get the min and max values for both totalRecords, and totalDelays. We
    // will use this for our scales.
    var totalRecordsMax = d3.max(totalRecords, function (d) {return d.value;}),
        totalRecordsMin = d3.min(totalRecords, function (d) {return d.value;});

    //Set the range and domain for our innerScale using the min and max from the totalRecords.
    innerScale.range([outerRange, innerRange]).domain([totalRecordsMin, totalRecordsMax]);

    //Set the color range similarly
    color.range([lowerColor, upperColor]).domain([totalRecordsMin, totalRecordsMax]);

    //Update our segments using the current data.
    var arcs = _selection.selectAll('path')
      .data(totalDelays)
      .attr('d', function (d,i) {return arc(d.value,i);})
      .attr('fill', function (d) {return color(d.value);})
      .attr('stroke', 'black')
      .attr('class', 'slice');

    //Add any new segments using the current data.
    arcs.enter().append('path')
      .attr('d', function (d,i) {return arc(d.value,i);})
      .attr('fill', function (d) {return color(d.value);})
      .attr('class', 'slice')
      .attr('stroke', 'black');

    //Remove and extra segments.
    arcs.exit().remove();

    //Attach our mouseover event.
    arcs.on('mouseover', mouseover);

    //Add our labels.
    var labels = _selection.selectAll('text')
        .data(totalDelays).enter()
      .append("text")
        .attr("transform", function(d,i) { return "translate(" + label.centroid(d,i) + ")"; })
        .attr("dy", ".35em")
        .attr("text-anchor", "middle")
        .text(function(d,i) { return i+1; });

    //Remove center text on chart update. TODO: Better way??
    _selection.selectAll('.centerText').remove();

    //Add the center text for the chart.
    var centerText = _selection.append('text')
      .attr('text-anchor', 'middle')
      .text('Mouse over a segment to see the total.')
      .attr('class', 'centerText');

    //On mouseover function to display segment total.
    function mouseover (d) {
      centerText.text('Total: ' + d.value);
    }
  }

  //Method to get/set the inner radius.
  chart.innerRadius = function (_innerRadius) {
    if(!arguments.length) return innerRadius;
    innerRadius = _innerRadius;
    return chart;
  };

  //Method to get/set the outer radius.
  chart.outerRadius = function (_outerRadius) {
    if(!arguments.length) return outerRadius;
    outerRadius = _outerRadius;
    return chart;
  };

  //Method to get/set the crossfilter group.
  chart.group = function (_group) {
    if(!arguments.length) return group;
    group = _group;
    return chart;
  };

  //Method to get/set the label offset.
  chart.offset = function (_offset) {
    if(!arguments.length) return offset;
    offset = _offset;
    return chart;
  };

  //Method to get/set the crossfilter dimension.
  chart.dimension = function (_dimension) {
    if(!arguments.length) return dimension;
    dimension = _dimension;
    return chart;
  };

  //Method to get/set the color range.
  chart.colorRange = function (_array) {
    if(!arguments.length) return [lowerColor, upperColor];
    lowerColor = _array[0];
    upperColor = _array[1];
    return chart;
  };

  //Method to get/set the radial range/
  chart.radialRange = function (_array) {
    if(!arguments.length) return [innerRange, outerRange];
    innerRange = _array[0];
    outerRange = _array[1];
    return chart;
  };

  //Finally, return the chart.
  return chart;
};

//Define our width and height for our visualizations.
var width = 570,
    height = 500;

//Instantiate our data manager module for each city.
var sanFranciscoDataManager = d3Edge.dataManager(),
    zurichDataManager = d3Edge.dataManager(),
    genevaDataManager = d3Edge.dataManager();

//Instantiate our radial module for each city.
var zurichRadial = d3Edge.radialHistogram().colorRange(['lightblue', 'darkblue'])
  .innerRadius(5)
  .outerRadius(200)
  .offset(15)
  .radialRange([100,200]);

//Instantiate our map module for Zurich.
var zurichMap = d3Edge.map()
  .center([8.5390, 47.3687])
  .scale(900000)
  .size([width, height]);

//Instantiate our map module for Geneva.
var genevaMap = d3Edge.map()
  .center([6.14, 46.20])
  .scale(900000)
  .size([width, height]);

//Instantiate our map module for San Francisco.
var sanFranciscoMap = d3Edge.map()
  .center([-122.4376, 37.77])
  .scale(900000)
  .size([width, height]);

//Bind our modules to the DOM.
d3.select('#zurich_map')
  .append('svg')
    .attr('width', width)
    .attr('height', height)
    .call(zurichMap);

d3.select('#geneva_map')
  .append('svg')
    .attr('width', width)
    .attr('height', height)
    .call(genevaMap);

d3.select('#san_francisco_map')
  .append('svg')
    .attr('width', width)
    .attr('height', height)
    .call(sanFranciscoMap);

//Set up the DOM for each city for the radial chart.
var zurichHist = d3.select('#zurich_hist')
  .append('svg')
  .attr('width', width)
  .attr('height', height)
  .append('g')
    .attr('transform', 'translate(' + width/2 + ',' + height/2 + ')');

//Load the routes data and pass our drawRoutes method as the callback to be executed once the data loads.
zurichDataManager.loadGeoJson('./data/zurich/routes_topo.json', zurichMap.drawRoutes);

//After the routes have been drawn, draw the stops.
zurichMap.on('routesEnd', function () {
  //Load the stops data and pass our drawStops method as the callback to be executed once the data loads.
  zurichDataManager.loadGeoJson('./data/zurich/stops_geo.json', zurichMap.drawStops);
});

//Load the routes data and pass our drawRoutes method as the callback to be executed once the data loads.
genevaDataManager.loadGeoJson('./data/geneva/routes_topo.json', genevaMap.drawRoutes);

//After the routes have been drawn, draw the stops.
genevaMap.on('routesEnd', function () {
  //Load the stops data and pass our drawStops method as the callback to be executed once the data loads.
  genevaDataManager.loadGeoJson('./data/geneva/stops_geo.json', genevaMap.drawStops);
});

//Load the routes data and pass our drawRoutes method as the callback to be executed once the data loads.
sanFranciscoDataManager.loadGeoJson('./data/san_francisco/routes_topo.json', sanFranciscoMap.drawRoutes);

//After the routes have been drawn, draw the stops.
sanFranciscoMap.on('routesEnd', function () {
  //Load the stops data and pass our drawStops method as the callback to be executed once the data loads.
  sanFranciscoDataManager.loadGeoJson('./data/san_francisco/stops_geo.json', sanFranciscoMap.drawStops);
});

//Load our Zurich data, and supply the cleaning function.
zurichDataManager.loadCsvData('./data/zurich/zurich_delay.csv', function(d){
  var timeFormat = d3.time.format('%Y-%m-%d %H:%M:%S %p');
  d.DELAY = +d.DELAY_MIN;
  delete d.DELAY_MIN;
  d.SCHEDULED = timeFormat.parse(d.SCHEDULED);
  d.LATITUDE = +d.LATITUDE;
  d.LONGITUDE = +d.LONGITUDE;
  d.LOCATION = [d.LONGITUDE, d.LATITUDE];
});

//Add our brush to the map.
zurichMap.addBrush();

//On map brushing, filter the stop metric data, pass filtered data into radial chart.
zurichMap.on('brushing', function (brush) {
  //Get the locations inside the brush.
  var filteredLocations = zurichDataManager.filterLocation(brush.extent()),
      //Get the delays inside the area.
      delaysByHourAndLocation = zurichDataManager.getDelays(filteredLocations);

  //Inspect the total number of events by hour;
  console.log(delaysByHourAndLocation[0].group().all());

  //Inspect the total number of delays by hour.
  console.log(delaysByHourAndLocation[1].all());

  zurichRadial.group(zurichDataManager.getDelays(filteredLocations)[1]).dimension(zurichDataManager.getDelays(filteredLocations)[0]);
  zurichHist.call(zurichRadial);
});


text:
package com.myrippleapps.mynotes.app.fragment;

// --Commented out by Inspection START (25-Dec-15 8:43 AM):
// --Commented out by Inspection START (25-Dec-15 8:43 AM):
////public class FirstSlide2 extends Fragment {
////    @Override
////    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
////        return inflater.inflate(R.layout.intro_2, container, false);
// --Commented out by Inspection STOP (25-Dec-15 8:43 AM)
//    }
//}
// --Commented out by Inspection STOP (25-Dec-15 8:43 AM)

redpajama_set_name: RedPajamaGithub


text:
function transform(line) {
  var values = line.split(',');

  var obj = new Object();
  obj.id = values[0]
  obj.name = values[1];
  obj.surname = values[2];
  obj.timestamp = values[3];
  var jsonString = JSON.stringify(obj);

  return jsonString;
}


text:
"""Tokenization classes for DistilBERT."""

from __future__ import absolute_import, division, print_function, unicode_literals

import collections
import logging
import os
import unicodedata
from io import open

from .tokenization_bert import BertTokenizer

logger = logging.getLogger(__name__)

VOCAB_FILES_NAMES = {'vocab_file': 'vocab.txt'}

PRETRAINED_VOCAB_FILES_MAP = {
    'vocab_file':
    {
        'distilbert-base-uncased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt",
        'distilbert-base-uncased-distilled-squad': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased-vocab.txt",
        'distilbert-base-german-cased': "https://s3.amazonaws.com/models.huggingface.co/bert/distilbert-base-german-cased-vocab.txt",
        'distilbert-base-multilingual-cased': "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-multilingual-cased-vocab.txt",
    }
}

PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
    'distilbert-base-uncased': 512,
    'distilbert-base-uncased-distilled-squad': 512,
    'distilbert-base-german-cased': 512,
    'distilbert-base-multilingual-cased': 512,
}

class DistilBertTokenizer(BertTokenizer):
    r"""
    Constructs a DistilBertTokenizer.
    :class:`~transformers.DistilBertTokenizer` is identical to BertTokenizer and runs end-to-end tokenization: punctuation splitting + wordpiece

    Args:
        vocab_file: Path to a one-wordpiece-per-line vocabulary file
        do_lower_case: Whether to lower case the input. Only has an effect when do_wordpiece_only=False
        do_basic_tokenize: Whether to do basic tokenization before wordpiece.
        max_len: An artificial maximum length to truncate tokenized sequences to; Effective maximum length is always the
            minimum of this value (if specified) and the underlying BERT model's sequence length.
        never_split: List of tokens which will never be split during tokenization. Only has an effect when
            do_wordpiece_only=False
    """

    vocab_files_names = VOCAB_FILES_NAMES
    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES


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

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link rel="stylesheet" type="text/css" href="css/style.css" />
<title>Test Groups Roles Promote</title>

<?php
require_once('test-util.php');
require_once(dirname(__FILE__) . '/../lib/ca-main.php');

echo '
';
echo '
groups_roles_promote
';

$ca = new CityApi();
$ca->debug = true;
$ca->json = true;

$groupid = 43682;
//$userid = 238801;
$roleid = 986632;

$args = array('title' => 'Leader');
$results = $ca->groups_roles_promote($groupid, $roleid, $args);

echo '
Formatted JSON results:
';
echo '
';
echo format_json($results);

echo '
';
echo '
';
?>


text:
  L'Épine est
       un village
       géographiquement positionné dans le département des Hautes-Alpes en Provence-Alpes-Côte d'Azur. Elle totalisait 171 habitants en 2008.

Le parc d'habitations, à L'Épine, était réparti en 2011 en 60 appartements et 137 maisons soit
 un marché relativement équilibré.

Si vous envisagez de emmenager à L'Épine, vous pourrez facilement trouver une maison à vendre.

La ville compte de multiples  équipements sportifs, elle dispose, entre autres, de quatre boucles de randonnée.

À coté de L'Épine sont positionnées géographiquement les villes de
Sorbiers localisée à 6 km, 38 habitants,
Méreuil à 9 km, 82 habitants,
Bruis localisée à 9 km, 67 habitants,
Ribeyret localisée à 4 km, 107 habitants,
Chanousse à 7 km, 44 habitants,
Montmorin localisée à 6 km, 88 habitants,
 entre autres. De plus, L'Épine est située à seulement 20 km de Laragne-Montéglin.


text: initSidebarItems({"static":[["IDENTITY_OP",""]],"struct":[["IdentityOp",""]]});


text:
package org.springframework.boot.docs.springbootfeatures.webapplications.webflux.fn;

//tag::code[]
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.RequestPredicate;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;

import static org.springframework.web.reactive.function.server.RequestPredicates.DELETE;
import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

@Configuration(proxyBeanMethods = false)
public class RoutingConfiguration {

	private static final RequestPredicate ACCEPT_JSON = accept(MediaType.APPLICATION_JSON);

	@Bean
	public RouterFunction<ServerResponse> monoRouterFunction(UserHandler userHandler) {
		// @formatter:off
		return route(
				GET("/{user}").and(ACCEPT_JSON), userHandler::getUser).andRoute(
				GET("/{user}/customers").and(ACCEPT_JSON), userHandler::getUserCustomers).andRoute(
				DELETE("/{user}").and(ACCEPT_JSON), userHandler::deleteUser);
		// @formatter:on
	}

}
// end::code[]


text:
#include <string>
#include <unordered_map>

#include "modsecurity/actions/action.h"
#include "src/actions/transformations/transformation.h"

#ifndef SRC_ACTIONS_TRANSFORMATIONS_LOWER_CASE_H_
#define SRC_ACTIONS_TRANSFORMATIONS_LOWER_CASE_H_

#ifdef __cplusplus

namespace modsecurity {
class Transaction;
namespace actions {
namespace transformations {

class LowerCase : public Transformation {
 public:
    explicit LowerCase(std::string action);
    std::string evaluate(std::string exp,
        Transaction *transaction) override;
};

}  // namespace transformations
}  // namespace actions
}  // namespace modsecurity

#endif

#endif  // SRC_ACTIONS_TRANSFORMATIONS_LOWER_CASE_H_


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

namespace Cat_play_time
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Въведете брой на почивните дни на година ");
            var restdays = int.Parse(Console.ReadLine());

            var playtime = (restdays * 127) + ((365 - restdays) * 63);

            if (playtime > 30000)
            {
                var a = playtime - 30000;
                var h = a / 60;
                var m = a % 60;
                Console.WriteLine("Tom will run away");
                Console.WriteLine($"{h} hours and {m} minutes more for play");
            }
            else
            {
                var a = 30000 - playtime;
                var h = a / 60;
                var m = a % 60;
                Console.WriteLine("Tom sleeps well");
                Console.WriteLine($"{h} hours and {m} minutes less for play");
            }
        }
    }
}


text:
  Gaujac est
       un village
       situé dans le département des Gers en Midi-Pyrénées. Elle comptait 54 habitants en 2008.

Le parc d'habitations, à Gaujac, se décomposait en 2011 en zero appartements et 41 maisons soit
 un marché plutôt équilibré.

À coté de Gaujac sont situées les villes de
 entre autres.

Si vous pensez emmenager à Gaujac, vous pourrez aisément trouver une maison à acheter.


text:
.class public final Lcom/google/android/gms/ads/search/SearchAdView;
.super Landroid/view/ViewGroup;

# instance fields
.field private final zznT:Lcom/google/android/gms/ads/internal/client/zzz;

# direct methods
.method public constructor <init>(Landroid/content/Context;)V
    .registers 3
    .param p1, "context"    # Landroid/content/Context;

    .prologue
    invoke-direct {p0, p1}, Landroid/view/ViewGroup;-><init>(Landroid/content/Context;)V

    new-instance v0, Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-direct {v0, p0}, Lcom/google/android/gms/ads/internal/client/zzz;-><init>(Landroid/view/ViewGroup;)V

    iput-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    return-void
.end method

.method public constructor <init>(Landroid/content/Context;Landroid/util/AttributeSet;)V
    .registers 5
    .param p1, "context"    # Landroid/content/Context;
    .param p2, "attrs"    # Landroid/util/AttributeSet;

    .prologue
    invoke-direct {p0, p1, p2}, Landroid/view/ViewGroup;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;)V

    new-instance v0, Lcom/google/android/gms/ads/internal/client/zzz;

    const/4 v1, 0x0

    invoke-direct {v0, p0, p2, v1}, Lcom/google/android/gms/ads/internal/client/zzz;-><init>(Landroid/view/ViewGroup;Landroid/util/AttributeSet;Z)V

    iput-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    return-void
.end method

.method public constructor <init>(Landroid/content/Context;Landroid/util/AttributeSet;I)V
    .registers 6
    .param p1, "context"    # Landroid/content/Context;
    .param p2, "attrs"    # Landroid/util/AttributeSet;
    .param p3, "defStyle"    # I

    .prologue
    invoke-direct {p0, p1, p2, p3}, Landroid/view/ViewGroup;-><init>(Landroid/content/Context;Landroid/util/AttributeSet;I)V

    new-instance v0, Lcom/google/android/gms/ads/internal/client/zzz;

    const/4 v1, 0x0

    invoke-direct {v0, p0, p2, v1}, Lcom/google/android/gms/ads/internal/client/zzz;-><init>(Landroid/view/ViewGroup;Landroid/util/AttributeSet;Z)V

    iput-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    return-void
.end method

# virtual methods
.method public destroy()V
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->destroy()V

    return-void
.end method

.method public getAdListener()Lcom/google/android/gms/ads/AdListener;
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->getAdListener()Lcom/google/android/gms/ads/AdListener;

    move-result-object v0

    return-object v0
.end method

.method public getAdSize()Lcom/google/android/gms/ads/AdSize;
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->getAdSize()Lcom/google/android/gms/ads/AdSize;

    move-result-object v0

    return-object v0
.end method

.method public getAdUnitId()Ljava/lang/String;
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->getAdUnitId()Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public loadAd(Lcom/google/android/gms/ads/search/SearchAdRequest;)V
    .registers 4
    .param p1, "searchAdRequest"    # Lcom/google/android/gms/ads/search/SearchAdRequest;

    .prologue
    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {p1}, Lcom/google/android/gms/ads/search/SearchAdRequest;->zzaF()Lcom/google/android/gms/ads/internal/client/zzy;

    move-result-object v1

    invoke-virtual {v0, v1}, Lcom/google/android/gms/ads/internal/client/zzz;->zza(Lcom/google/android/gms/ads/internal/client/zzy;)V

    return-void
.end method

.method protected onLayout(ZIIII)V
    .registers 11
    .param p1, "changed"    # Z
    .param p2, "left"    # I
    .param p3, "top"    # I
    .param p4, "right"    # I
    .param p5, "bottom"    # I

    .prologue
    const/4 v0, 0x0

    invoke-virtual {p0, v0}, Lcom/google/android/gms/ads/search/SearchAdView;->getChildAt(I)Landroid/view/View;

    move-result-object v0

    if-eqz v0, :cond_26

    invoke-virtual {v0}, Landroid/view/View;->getVisibility()I

    move-result v1

    const/16 v2, 0x8

    if-eq v1, v2, :cond_26

    invoke-virtual {v0}, Landroid/view/View;->getMeasuredWidth()I

    move-result v1

    invoke-virtual {v0}, Landroid/view/View;->getMeasuredHeight()I

    move-result v2

    sub-int v3, p4, p2

    sub-int/2addr v3, v1

    div-int/lit8 v3, v3, 0x2

    sub-int v4, p5, p3

    sub-int/2addr v4, v2

    div-int/lit8 v4, v4, 0x2

    add-int/2addr v1, v3

    add-int/2addr v2, v4

    invoke-virtual {v0, v3, v4, v1, v2}, Landroid/view/View;->layout(IIII)V

    :cond_26
    return-void
.end method

.method protected onMeasure(II)V
    .registers 7
    .param p1, "widthMeasureSpec"    # I
    .param p2, "heightMeasureSpec"    # I

    .prologue
    const/4 v0, 0x0

    invoke-virtual {p0, v0}, Lcom/google/android/gms/ads/search/SearchAdView;->getChildAt(I)Landroid/view/View;

    move-result-object v2

    if-eqz v2, :cond_36

    invoke-virtual {v2}, Landroid/view/View;->getVisibility()I

    move-result v1

    const/16 v3, 0x8

    if-eq v1, v3, :cond_36

    invoke-virtual {p0, v2, p1, p2}, Lcom/google/android/gms/ads/search/SearchAdView;->measureChild(Landroid/view/View;II)V

    invoke-virtual {v2}, Landroid/view/View;->getMeasuredWidth()I

    move-result v1

    invoke-virtual {v2}, Landroid/view/View;->getMeasuredHeight()I

    move-result v0

    :goto_1a
    invoke-virtual {p0}, Lcom/google/android/gms/ads/search/SearchAdView;->getSuggestedMinimumWidth()I

    move-result v2

    invoke-static {v1, v2}, Ljava/lang/Math;->max(II)I

    move-result v1

    invoke-virtual {p0}, Lcom/google/android/gms/ads/search/SearchAdView;->getSuggestedMinimumHeight()I

    move-result v2

    invoke-static {v0, v2}, Ljava/lang/Math;->max(II)I

    move-result v0

    invoke-static {v1, p1}, Landroid/view/View;->resolveSize(II)I

    move-result v1

    invoke-static {v0, p2}, Landroid/view/View;->resolveSize(II)I

    move-result v0

    invoke-virtual {p0, v1, v0}, Lcom/google/android/gms/ads/search/SearchAdView;->setMeasuredDimension(II)V

    return-void

    :cond_36
    invoke-virtual {p0}, Lcom/google/android/gms/ads/search/SearchAdView;->getAdSize()Lcom/google/android/gms/ads/AdSize;

    move-result-object v2

    if-eqz v2, :cond_49

    invoke-virtual {p0}, Lcom/google/android/gms/ads/search/SearchAdView;->getContext()Landroid/content/Context;

    move-result-object v0

    invoke-virtual {v2, v0}, Lcom/google/android/gms/ads/AdSize;->getWidthInPixels(Landroid/content/Context;)I

    move-result v1

    invoke-virtual {v2, v0}, Lcom/google/android/gms/ads/AdSize;->getHeightInPixels(Landroid/content/Context;)I

    move-result v0

    goto :goto_1a

    :cond_49
    move v1, v0

    goto :goto_1a
.end method

.method public pause()V
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->pause()V

    return-void
.end method

.method public resume()V
    .registers 2

    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0}, Lcom/google/android/gms/ads/internal/client/zzz;->resume()V

    return-void
.end method

.method public setAdListener(Lcom/google/android/gms/ads/AdListener;)V
    .registers 3
    .param p1, "adListener"    # Lcom/google/android/gms/ads/AdListener;

    .prologue
    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0, p1}, Lcom/google/android/gms/ads/internal/client/zzz;->setAdListener(Lcom/google/android/gms/ads/AdListener;)V

    return-void
.end method

.method public setAdSize(Lcom/google/android/gms/ads/AdSize;)V
    .registers 5
    .param p1, "adSize"    # Lcom/google/android/gms/ads/AdSize;

    .prologue
    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    const/4 v1, 0x1

    new-array v1, v1, [Lcom/google/android/gms/ads/AdSize;

    const/4 v2, 0x0

    aput-object p1, v1, v2

    invoke-virtual {v0, v1}, Lcom/google/android/gms/ads/internal/client/zzz;->setAdSizes([Lcom/google/android/gms/ads/AdSize;)V

    return-void
.end method

.method public setAdUnitId(Ljava/lang/String;)V
    .registers 3
    .param p1, "adUnitId"    # Ljava/lang/String;

    .prologue
    iget-object v0, p0, Lcom/google/android/gms/ads/search/SearchAdView;->zznT:Lcom/google/android/gms/ads/internal/client/zzz;

    invoke-virtual {v0, p1}, Lcom/google/android/gms/ads/internal/client/zzz;->setAdUnitId(Ljava/lang/String;)V

    return-void
.end method


text:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>Gateway</display-name>
  <welcome-file-list>
    <welcome-file>main.html</welcome-file>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>

<!--
  -->
  <servlet>
    <servlet-name>BackRcvResponse</servlet-name>
    <servlet-class>com.unionpay.acp.demo.BackRcvResponse</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>BackRcvResponse</servlet-name>
    <url-pattern>/acp_back_url.do</url-pattern>
  </servlet-mapping>
  <servlet>
    <servlet-name>FrontRcvResponse</servlet-name>
    <servlet-class>com.unionpay.acp.demo.FrontRcvResponse</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>FrontRcvResponse</servlet-name>
    <url-pattern>/acp_front_url.do</url-pattern>
  </servlet-mapping>
</web-app>


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

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import io.prestosql.spi.connector.ConnectorTableHandle;
import io.prestosql.spi.connector.RecordCursor;
import io.prestosql.spi.connector.RecordSet;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.net.URI;
import java.util.LinkedHashMap;
import java.util.Map;

import static io.prestosql.spi.type.BigintType.BIGINT;
import static io.prestosql.spi.type.VarcharType.createUnboundedVarcharType;
import static io.prestosql.testing.TestingConnectorSession.SESSION;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;

public class TestExampleRecordSetProvider
{
    private ExampleHttpServer exampleHttpServer;
    private URI dataUri;

    @Test
    public void testGetRecordSet()
    {
        ConnectorTableHandle tableHandle = new ExampleTableHandle("schema", "table");
        ExampleRecordSetProvider recordSetProvider = new ExampleRecordSetProvider();
        RecordSet recordSet = recordSetProvider.getRecordSet(ExampleTransactionHandle.INSTANCE, SESSION, new ExampleSplit(dataUri), tableHandle, ImmutableList.of(
                new ExampleColumnHandle("text", createUnboundedVarcharType(), 0),
                new ExampleColumnHandle("value", BIGINT, 1)));
        assertNotNull(recordSet, "recordSet is null");

        RecordCursor cursor = recordSet.cursor();
        assertNotNull(cursor, "cursor is null");

        Map<String, Long> data = new LinkedHashMap<>();
        while (cursor.advanceNextPosition()) {
            data.put(cursor.getSlice(0).toStringUtf8(), cursor.getLong(1));
        }
        assertEquals(data, ImmutableMap.<String, Long>builder()
                .put("ten", 10L)
                .put("eleven", 11L)
                .put("twelve", 12L)
                .build());
    }

    //
    // Start http server for testing
    //

    @BeforeClass
    public void setUp()
    {
        exampleHttpServer = new ExampleHttpServer();
        dataUri = exampleHttpServer.resolve("/example-data/numbers-2.csv");
    }

    @AfterClass(alwaysRun = true)
    public void tearDown()
    {
        if (exampleHttpServer != null) {
            exampleHttpServer.stop();
        }
    }
}


text:
import com.sksamuel.scapegoat.sbt.ScapegoatSbtPlugin.autoImport._
import com.typesafe.sbt.{ GitBranchPrompt, GitVersioning }
import com.typesafe.sbt.SbtScalariform.{ ScalariformKeys, defaultScalariformSettings }
import net.virtualvoid.sbt.graph.Plugin.graphSettings
import org.scalajs.sbtplugin.ScalaJSPlugin
import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._
import playscalajs.ScalaJSPlay
import playscalajs.ScalaJSPlay.autoImport._
import sbt.Keys._
import sbt._

object Client {
  lazy val client = (project in file("client")).settings(
    scalaVersion := Shared.Versions.scala,
    persistLauncher := false,
    sourceMapsDirectories += Shared.sharedJs.base / "..",
    unmanagedSourceDirectories in Compile := Seq((scalaSource in Compile).value),
    libraryDependencies ++= Seq("com.lihaoyi" %%% "upickle" % "0.3.4"),
    scalaJSStage in Global := FastOptStage,
    scapegoatIgnoredFiles := Seq(".*/JsonUtils.scala", ".*/JsonSerializers.scala"),
    ScalariformKeys.preferences := ScalariformKeys.preferences.value
  )
    .enablePlugins(GitVersioning)
    .enablePlugins(GitBranchPrompt)
    .settings(graphSettings: _*)
    .settings(defaultScalariformSettings: _*)
    .enablePlugins(ScalaJSPlugin, ScalaJSPlay)
    .dependsOn(Shared.sharedJs)
}


text:
using OCM.API.Common.Model;
using System;
using System.Collections.Generic;

namespace OCM.API.Common
{

    public class NullSafeDictionary<TKey, TValue> : Dictionary<TKey, TValue> where TValue : class
    {
        // https://stackoverflow.com/questions/14150508/how-to-get-null-instead-of-the-keynotfoundexception-accessing-dictionary-value-b/14150668#14150668
        public new TValue this[TKey key]
        {
            get
            {
                if (!ContainsKey(key))
                    return null;
                else
                    return base[key];
            }
            set
            {
                if (!ContainsKey(key))
                    Add(key, value);
                else
                    base[key] = value;
            }
        }
    }

    public class APIRequestParams : ServiceParameterParser
    {
        private const int MAX_API_VERSION = 2;

        //result filters
        public int? APIVersion { get; set; }

        public string APIKey { get; set; }

        public string Action { get; set; }

        public string DataProviderName { get; set; }

        public string OperatorName { get; set; }

        public string LocationTitle { get; set; }

        public string Address { get; set; }

        public double? Latitude { get; set; }

        public double? Longitude { get; set; }

        public double? Distance { get; set; }

        public DistanceUnit DistanceUnit { get; set; }

        public string CountryCode { get; set; }

        public string ConnectionType { get; set; }

        public int? SubmissionStatusTypeID { get; set; }

        public int MaxResults { get; set; }

        public bool EnableCaching { get; set; }

        public bool IncludeComments { get; set; }

        public bool IsVerboseOutput { get; set; }

        public bool IsCompactOutput { get; set; }

        public bool IsCamelCaseOutput { get; set; }

        public bool IsEnvelopedResponse { get; set; }

        /// <summary>
        /// if true, api will try to use mongodb to query
        /// </summary>
        public bool AllowMirrorDB { get; set; }

        /// <summary>
        /// if true, api will try to use backing store database (SQL) to query
        /// </summary>
        public bool AllowDataStoreDB { get; set; }

        public bool? IsOpenData { get; set; }

        public string Callback { get; set; }

        public double? MinPowerKW { get; set; }
        public double? MaxPowerKW { get; set; }

        /// <summary>
        /// list of (lat,lng) points to search along (route etc)
        /// </summary>
        public List<LatLon> Polyline { get; set; }

        /// <summary>
        /// pair of top left and bottom right coords for bounding box. If specified then latitude/longitude params are ignored, distance is instead from box centre
        /// </summary>
        public List<LatLon> BoundingBox { get; set; }

        /// <summary>
        /// list of (lat,lng) points comprising the area to search within, for instance a region shape
        /// </summary>
        public List<LatLon> Polygon { get; set; }

        public int[] ChargePointIDs { get; set; }

        public int[] ConnectionTypeIDs { get; set; }

        public int[] OperatorIDs { get; set; }

        public int[] DataProviderIDs { get; set; }

        public int[] CountryIDs { get; set; }

        public int[] LevelIDs { get; set; }

        public int[] UsageTypeIDs { get; set; }

        public int[] StatusTypeIDs { get; set; }

        public string[] Postcodes { get; set; }

        public DateTime? ChangesFromDate { get; set; }

        public DateTime? CreatedFromDate { get; set; }

        public string SortBy { get; set; }

        /// <summary>
        /// If supplied, results will be ID's greater than the given value, used for batch imports
        /// </summary>
        public int? GreaterThanId { get; set; }

        /// <summary>
        /// If supplied and greater than 1 the API will return a random sample of matching results, the higher the value the less results returned.
        /// </summary>
        public int? LevelOfDetail { get; set; }

        #region deprecated api filters

        public bool FastChargeOnly { get; set; }

        #endregion deprecated api filters

        public APIRequestParams()
        {
            DistanceUnit = DistanceUnit.Miles;
            MaxResults = 100;
            APIVersion = null;
            IsVerboseOutput = true;
            IsCompactOutput = false;
            AllowMirrorDB = true;
            AllowDataStoreDB = true;
        }

        public bool IsLegacyAPICall
        {
            get
            {
                if (APIVersion == null || APIVersion < MAX_API_VERSION)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        public void ParseParameters(APIRequestParams settings, NullSafeDictionary<string, string> requestParams)
        {
            //get parameter values if any
            if (!String.IsNullOrEmpty(requestParams["v"])) settings.APIVersion = ParseInt(requestParams["v"]);
            if (settings.APIVersion > MAX_API_VERSION) settings.APIVersion = MAX_API_VERSION;

            if (!String.IsNullOrEmpty(requestParams["action"])) settings.Action = ParseString(requestParams["action"]);

            if (!String.IsNullOrEmpty(requestParams["apikey"])) settings.APIKey = ParseString(requestParams["apikey"]);

            // accept either id or chargepointid params
            if (!String.IsNullOrEmpty(requestParams["id"])) settings.ChargePointIDs = ParseIntList(requestParams["id"]);
            if (!String.IsNullOrEmpty(requestParams["chargepointid"])) settings.ChargePointIDs = ParseIntList(requestParams["chargepointid"]);

            if (!String.IsNullOrEmpty(requestParams["greaterthanid"])) settings.GreaterThanId = ParseInt(requestParams["greaterthanid"]);

            if (!String.IsNullOrEmpty(requestParams["operatorname"])) settings.OperatorName = ParseString(requestParams["operatorname"]);
            if (!String.IsNullOrEmpty(requestParams["operatorid"])) settings.OperatorIDs = ParseIntList(requestParams["operatorid"]);
            if (!String.IsNullOrEmpty(requestParams["connectiontypeid"])) settings.ConnectionTypeIDs = ParseIntList(requestParams["connectiontypeid"]);
            if (!String.IsNullOrEmpty(requestParams["countryid"])) settings.CountryIDs = ParseIntList(requestParams["countryid"]);
            if (!String.IsNullOrEmpty(requestParams["levelid"])) settings.LevelIDs = ParseIntList(requestParams["levelid"]);
            if (!String.IsNullOrEmpty(requestParams["usagetypeid"])) settings.UsageTypeIDs = ParseIntList(requestParams["usagetypeid"]);
            if (!String.IsNullOrEmpty(requestParams["statustypeid"])) settings.StatusTypeIDs = ParseIntList(requestParams["statustypeid"]);
            if (!String.IsNullOrEmpty(requestParams["dataproviderid"])) settings.DataProviderIDs = ParseIntList(requestParams["dataproviderid"]);
            if (!String.IsNullOrEmpty(requestParams["opendata"])) settings.IsOpenData = ParseBoolNullable(requestParams["opendata"]);

            if (!String.IsNullOrEmpty(requestParams["minpowerkw"]))
            {
                settings.MinPowerKW = ParseDouble(requestParams["minpowerkw"]);
                if (settings.MinPowerKW < 1) settings.MinPowerKW = null;
            }

            if (!String.IsNullOrEmpty(requestParams["maxpowerkw"]))
            {
                settings.MaxPowerKW = ParseDouble(requestParams["maxpowerkw"]);
                if (settings.MaxPowerKW < 1) settings.MaxPowerKW = null;
            }

            if (!String.IsNullOrEmpty(requestParams["dataprovidername"])) settings.DataProviderName = ParseString(requestParams["dataprovidername"]);
            if (!String.IsNullOrEmpty(requestParams["locationtitle"])) settings.LocationTitle = ParseString(requestParams["locationtitle"]);
            if (!String.IsNullOrEmpty(requestParams["address"])) settings.Address = ParseString(requestParams["address"]);
            if (!String.IsNullOrEmpty(requestParams["postcodes"])) settings.Postcodes = ParseStringList(requestParams["postcodes"]);
            if (!String.IsNullOrEmpty(requestParams["countrycode"])) settings.CountryCode = ParseString(requestParams["countrycode"]);

            if (!String.IsNullOrEmpty(requestParams["latitude"]))
            {
                settings.Latitude = ParseDouble(requestParams["latitude"]);
                if (settings.Latitude < -90 || settings.Latitude > 90) settings.Latitude = null;
            }

            if (!String.IsNullOrEmpty(requestParams["longitude"]))
            {
                settings.Longitude = ParseDouble(requestParams["longitude"]);
                if (settings.Longitude < -180 || settings.Longitude > 180) settings.Longitude = null;
            }

            if (!String.IsNullOrEmpty(requestParams["distance"])) settings.Distance = ParseDouble(requestParams["distance"]);
            if (!String.IsNullOrEmpty(requestParams["distanceunit"])) settings.DistanceUnit = ParseDistanceUnit(requestParams["distanceunit"]);

            if (!String.IsNullOrEmpty(requestParams["polyline"])) settings.Polyline = ParsePolyline(requestParams["polyline"]);
            //e.g. |k~aEm|bbUewBx}C_kEnyCi}Edn@d\ssFb\kyN
            //settings.Polyline = ParsePolyline("_p~iF~ps|U_ulLnnqC_mqNvxq`@");
            //settings.Polyline = ParsePolyline("(38.5, -120.2), (40.7, -120.95), (43.252, -126.453)");

            if (!String.IsNullOrEmpty(requestParams["boundingbox"])) settings.BoundingBox = ParseBoundingBox(requestParams["boundingbox"]);     //e.g. (-31.947017,115.803974),(-31.956672,115.819968)
            if (!String.IsNullOrEmpty(requestParams["polygon"])) settings.Polygon = ParsePolygon(requestParams["polygon"], true);

            if (!String.IsNullOrEmpty(requestParams["connectiontype"])) settings.ConnectionType = ParseString(requestParams["connectiontype"]);
            if (!String.IsNullOrEmpty(requestParams["submissionstatustypeid"])) settings.SubmissionStatusTypeID = ParseInt(requestParams["submissionstatustypeid"]);
            if (!String.IsNullOrEmpty(requestParams["modifiedsince"])) settings.ChangesFromDate = ParseDate(requestParams["modifiedsince"]);
            if (!String.IsNullOrEmpty(requestParams["createdsince"])) settings.CreatedFromDate = ParseDate(requestParams["createdsince"]);

            if (!String.IsNullOrEmpty(requestParams["levelofdetail"])) settings.LevelOfDetail = ParseInt(requestParams["levelofdetail"]);
            if (!String.IsNullOrEmpty(requestParams["enablecaching"])) settings.EnableCaching = ParseBool(requestParams["enablecaching"], true);
            if (!String.IsNullOrEmpty(requestParams["allowmirror"])) settings.AllowMirrorDB = ParseBool(requestParams["allowmirror"], false);
            if (!String.IsNullOrEmpty(requestParams["includecomments"])) settings.IncludeComments = ParseBool(requestParams["includecomments"], false);
            if (!String.IsNullOrEmpty(requestParams["verbose"])) settings.IsVerboseOutput = ParseBool(requestParams["verbose"], false);
            if (!String.IsNullOrEmpty(requestParams["compact"])) settings.IsCompactOutput = ParseBool(requestParams["compact"], false);
            if (!String.IsNullOrEmpty(requestParams["camelcase"])) settings.IsCamelCaseOutput = ParseBool(requestParams["camelcase"], false);
            if (!String.IsNullOrEmpty(requestParams["callback"])) settings.Callback = ParseString(requestParams["callback"]);

            if (!String.IsNullOrEmpty(requestParams["maxresults"]))
            {
                try
                {
                    settings.MaxResults = int.Parse(requestParams["maxresults"]);
                }
                catch (Exception)
                {
                    settings.MaxResults = 100;
                }
            }

            if (!String.IsNullOrEmpty(requestParams["sortby"]))
            {
                settings.SortBy = requestParams["sortby"].Trim().ToLower();
            }

            //default action
            if (String.IsNullOrEmpty(settings.Action))
            {
                settings.Action = "getchargepoints";
            }

            //handle deprecated items
            if (settings.APIVersion == null || settings.APIVersion == 1)
            {
                if (!String.IsNullOrEmpty(requestParams["fastchargeonly"])) settings.FastChargeOnly = ParseBool(requestParams["fastchargeonly"], false);
            }
        }

        /// <summary>
        /// Uses the search filters to create a simple cache key for the returned output
        /// </summary>
        public string HashKey
        {
            get
            {
                //return this.GetHashCode().ToString();

                string key = "";

                if (APIKey != null) key += ":" + APIKey;
                if (Action != null) key += ":" + Action;
                if (DataProviderName != null) key += ":" + DataProviderName;
                if (OperatorName != null) key += ":" + OperatorName;
                if (LocationTitle != null) key += ":" + LocationTitle;
                if (Address != null) key += ":" + Address;
                if (Latitude != null) key += ":" + Latitude.ToString();
                if (Longitude != null) key += ":" + Longitude.ToString();
                if (Distance != null) key += ":" + Distance.ToString();
                key += ":" + DistanceUnit.ToString();
                if (CountryCode != null) key += ":" + CountryCode;
                if (ConnectionType != null) key += ":" + ConnectionType;
                key += ":" + FastChargeOnly.ToString();
                if (SubmissionStatusTypeID != null) key += ":" + SubmissionStatusTypeID.ToString();
                key += ":" + MaxResults.ToString();
                key += ":" + IncludeComments.ToString();
                key += ":" + this.IsCompactOutput.ToString();
                if (ChargePointIDs != null) key += ":cp_id:" + IntArrayToString(ChargePointIDs);
                if (CountryIDs != null) key += ":c_id:" + IntArrayToString(CountryIDs);
                if (LevelIDs != null) key += ":l_id:" + IntArrayToString(LevelIDs);
                if (ConnectionTypeIDs != null) key += ":ct_id:" + IntArrayToString(ConnectionTypeIDs);
                if (OperatorIDs != null) key += ":op_id:" + IntArrayToString(OperatorIDs);
                if (UsageTypeIDs != null) key += ":usg_id:" + IntArrayToString(UsageTypeIDs);
                if (StatusTypeIDs != null) key += ":stat_id:" + IntArrayToString(StatusTypeIDs);
                if (DataProviderIDs != null) key += ":prov_id:" + IntArrayToString(DataProviderIDs);
                if (IsOpenData != null) key += ":opendata:" + IsOpenData.ToString();
                if (MinPowerKW != null) key += ":minpowerkw:" + MinPowerKW.ToString();
                if (Polyline != null) key += ":polyline:" + Polyline.GetHashCode().ToString();
                if (Polygon != null) key += ":polygon:" + Polygon.GetHashCode().ToString();
                if (BoundingBox != null) key += ":boundingbox:" + BoundingBox.GetHashCode().ToString();
                if (LevelOfDetail > 1) key += ":lod:" + LevelOfDetail.ToString();
                if (ChangesFromDate != null) key += ":modified:" + ChangesFromDate.Value.Ticks.ToString();

                return OCM.Core.Util.SecurityHelper.GetMd5Hash(key);
            }
        }

        public string IntArrayToString(int[] array)
        {
            string output = "{";
            foreach (int val in array)
            {
                output += val.ToString() + ",";
            }
            output += "}";
            return output;
        }
    }
}


text:
package com.ducetech.api.model.vo;

import java.io.Serializable;

/**
 * Created by lenzhao on 17-2-2.
 */
public class AdvertiserVO implements Serializable {

    private String advertiserName;

    private String description;

    public String getAdvertiserName() {
        return advertiserName;
    }

    public void setAdvertiserName(String advertiserName) {
        this.advertiserName = advertiserName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}


text:
package com.msci.carrental.client.interpreter.command;

import java.util.List;

import com.msci.carrental.client.interpreter.BookingHandlerInterface;
import com.msci.carrental.client.interpreter.CommandHandlerInterface;
import com.msci.carrental.client.interpreter.CommandResult;
import com.msci.carrental.client.util.Util;
import com.msci.carrental.client.ws.CarRentalServiceInterface;

public class ListOfCarsAvailableForRentCommand implements CommandHandlerInterface {
	private CarRentalServiceInterface service;

	@Override
	public void setCarRentalService(CarRentalServiceInterface carRentalServiceInterface) {
		this.service = carRentalServiceInterface;
	}
	@Override
	public String getCommandName() {
		return "list";
	}

	@Override
	public CommandResult invoke(List<String> parameters) {
		CommandResult result = new CommandResult();
		result.addMessage("List of car instances by country available for rent:");
		service.getAvailableCarsForRental().stream().forEach(
				carType->result.addMessage(
						"Type: " + Util.getBoldText(carType.getCarType().name()) +
						", Country: " + Util.getBoldText(""+carType.getCountry()) +
						", Number Plate:" + Util.getBoldText(carType.getNumberPlate())));

		return result ;
	}

	@Override
	public List<String> getCommandDescription() {
		return null;
	}

	@Override
	public List<String> getParameterDescription() {
		return null;
	}
	@Override
	public String getTagLine() {

		return "Returns the list of available car types/instances for rent";
	}
	@Override
	public void setBookingHandler(BookingHandlerInterface bookingHandlerInterface) {
	}

}


text:
unless defined?(ActionView)
  raise "Rails is not loaded - Temple::Templates::Rails cannot be used"
end

if ::ActionPack::VERSION::MAJOR < 3
  raise "Temple supports only Rails 3.x and greater, your Rails version is #{::ActionPack::VERSION::STRING}"
end

module Temple
  module Templates
    if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR < 1
      class Rails < ActionView::TemplateHandler
        include ActionView::TemplateHandlers::Compilable
        extend Mixins::Template

        def compile(template)
          # Overwrite option: No streaming support in Rails < 3.1
          opts = {}.update(self.class.default_options).update(:file => template.identifier, :streaming => false)
          self.class.compile(template.source, opts)
        end

        def self.register_as(*names)
          names.each do |name|
            ActionView::Template.register_template_handler name.to_sym, self
          end
        end
      end
    else
      class Rails
        extend Mixins::Template

        def call(template)
          opts = {}.update(self.class.default_options).update(:file => template.identifier)
          self.class.compile(template.source, opts)
        end

        def supports_streaming?
          self.class.default_options[:streaming]
        end

        def self.register_as(*names)
          names.each do |name|
            ActionView::Template.register_template_handler name.to_sym, new
          end
        end
      end
    end
  end
end


text:
package amu.roboclub.ui.fragments;

import android.content.res.Configuration;
import android.os.Bundle;
import android.support.design.widget.Snackbar;
import android.support.v4.app.Fragment;
import android.support.v7.widget.DefaultItemAnimator;
import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import com.firebase.ui.database.FirebaseRecyclerAdapter;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

import amu.roboclub.R;
import amu.roboclub.models.Contribution;
import amu.roboclub.ui.viewholder.ContributionHolder;
import butterknife.BindView;
import butterknife.ButterKnife;

public class ContributionFragment extends Fragment {

    @BindView(R.id.recyclerView)
    RecyclerView recyclerView;

    public static ContributionFragment newInstance() {
        return new ContributionFragment();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, final ViewGroup container,
                             Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_contribution, container, false);

        ButterKnife.bind(this, root);

        recyclerView.setItemAnimator(new DefaultItemAnimator());
        GridLayoutManager gridLayoutManager = new GridLayoutManager(getContext(), 1);
        recyclerView.setLayoutManager(gridLayoutManager);

        final Snackbar snackbar = Snackbar.make(recyclerView, R.string.loading_contributors, Snackbar.LENGTH_INDEFINITE);
        snackbar.show();

        DatabaseReference contributionReference = FirebaseDatabase.getInstance().getReference("contribution");
        FirebaseRecyclerAdapter contributionAdapter = new FirebaseRecyclerAdapter<Contribution, ContributionHolder>
                (Contribution.class, R.layout.item_contribution, ContributionHolder.class, contributionReference) {

            @Override
            protected void populateViewHolder(ContributionHolder holder, Contribution contribution, int position) {
                if (snackbar.isShown())
                    snackbar.dismiss();
                holder.setContribution(contribution);
            }

            @Override
            public Contribution getItem(int position) {
                return super.getItem(getItemCount() - 1 - position);
            }
        };

        recyclerView.setAdapter(contributionAdapter);

        if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
            gridLayoutManager.setSpanCount(2);
        }

        return root;
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
    }
}


text:
'use strict';

var isCopy         = require('es5-ext/array/#/is-copy')
  , d              = require('d')
  , makeEl         = require('dom-ext/document/#/make-element')
  , dispatchEvt    = require('dom-ext/html-element/#/dispatch-event-2')
  , resolveOptions = require('./utils/resolve-options')
  , DOMInput       = require('./_controls/input')
  , DOMRadio       = require('./_controls/radio')
  , DOMCheckbox    = require('./_controls/checkbox')
  , eventOpts      = require('./_event-options')

  , isArray = Array.isArray, defineProperties = Object.defineProperties
  , getValue =
	Object.getOwnPropertyDescriptor(DOMCheckbox.prototype, 'value').get
  , getName = Object.getOwnPropertyDescriptor(DOMInput.prototype, 'name').get
  , Radio, Checkbox, arrResult = ['0', '1'].sort(), getLabel;

getLabel = function (name, options, type) {
	name += 'Label';
	if (options[name]) return options[name];
	options = options.dbOptions;
	if (options[name]) return options[name];
	return type[name];
};

Radio = function (document, type/*, options*/) {
	var tOption, fOption, options = arguments[2], reverse;
	this.type = type;
	options = resolveOptions(options, type);
	DOMRadio.call(this, document, type, options);
	tOption = this.createOption('1', getLabel('true', options, type),
		options.controls && options.controls[1]);
	fOption = this.createOption('0', getLabel('false', options, type),
		options.controls && options.controls[0]);
	this.items['1'].setAttribute('data-type', 'boolean');
	this.items['0'].setAttribute('data-type', 'boolean');

	reverse = Number(options.order) < 0;
	this.dom.appendChild(reverse ? fOption : tOption);
	this.dom.appendChild(reverse ? tOption : fOption);
};
Radio.prototype = Object.create(DOMRadio.prototype, { constructor: d(Radio) });

Checkbox = function (document, type/*, options*/) {
	DOMCheckbox.apply(this, arguments);
};
Checkbox.prototype = Object.create(DOMCheckbox.prototype, {
	constructor: d(Checkbox),
	_value: d('0'),
	_render: d(function () {
		var el = makeEl.bind(this.document);
		this.dom = el('span', this.control = el('input',
			{ type: 'checkbox', 'data-type': 'boolean', value: '1' }),
			this.hidden = el('input', { type: 'hidden',
				'data-type': 'boolean', value: '0' }));
	}),
	name: d.gs(getName, function (name) {
		this._name = name;
		name = this.name;
		if (name) {
			this.control.setAttribute('name', name);
			this.hidden.setAttribute('name', name);
		} else {
			this.control.removeAttribute('name');
			this.hidden.removeAttribute('name');
		}
	}),
	inputValue: d.gs(function () {
		return this.control.checked ? '1' : '0';
	}, function (nu) {
		var old = this.inputValue;

		if (nu !== '1') this.control.removeAttribute('checked');
		else this.control.setAttribute('checked', 'checked');

		this._value = nu;
		if (nu !== old) {
			this.control.checked = (nu === '1');
			try {
				dispatchEvt.call(this.control, 'change', eventOpts);
			} catch (ignore) {}
		} else {
			this.onChange();
		}
	}),
	value: d.gs(getValue, function (value) {
		value = this.type.toInputValue(value);
		if (value == null) value = '0';
		this.inputValue = value;
	})
});

module.exports = exports = function (db) {
	defineProperties(db.Boolean, {
		fromInputValue: d(function (value) {
			if (value == null) return undefined;
			if (value === '0') return false;
			if (value === '1') return true;
			if (isArray(value) && isCopy.call(value.sort(), arrResult)) {
				return true;
			}
			return null;
		}),
		toInputValue: d(function (value) {
			if (value == null) return null;
			return value.valueOf() ? '1' : '0';
		}),
		DOMRadio: d(Radio),
		DOMCheckbox: d(Checkbox),
		toDOMInput: d(function (document/*, options*/) {
			var options = resolveOptions(arguments[1], this);
			if (options.multiple) {
				return new this.DOMMultipleInput(document, this, options);
			}
			if (options.type === 'checkbox') {
				return new this.DOMCheckbox(document, this, options);
			}
			return new this.DOMRadio(document, this, options);
		})
	});
};

exports.Radio = Radio;
exports.Checkbox = Checkbox;


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System.Collections.Immutable;

namespace Microsoft.VisualStudio.LanguageServices.ProjectSystem;

/// <summary>
/// A class that provides constants for common MSBuild property names.
/// </summary>
internal static class BuildPropertyNames
{
    // Properties received whenever a project is updated.
    //
    // Supported properties can be found in dotnet/project-system repo
    // https://github.com/dotnet/project-system/blob/main/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Rules/LanguageService.xaml.

    public const string RootNamespace = nameof(RootNamespace);
    public const string MaxSupportedLangVersion = nameof(MaxSupportedLangVersion);
    public const string RunAnalyzers = nameof(RunAnalyzers);
    public const string RunAnalyzersDuringLiveAnalysis = nameof(RunAnalyzersDuringLiveAnalysis);
    public const string TemporaryDependencyNodeTargetIdentifier = nameof(TemporaryDependencyNodeTargetIdentifier);
    public const string TargetRefPath = nameof(TargetRefPath);

    // Properties requested at project creation time.

    public const string MSBuildProjectFullPath = nameof(MSBuildProjectFullPath);
    public const string TargetPath = nameof(TargetPath);
    public const string AssemblyName = nameof(AssemblyName);
    public const string CommandLineArgsForDesignTimeEvaluation = nameof(CommandLineArgsForDesignTimeEvaluation);

    public static readonly ImmutableArray<string> InitialEvaluationPropertyNames = ImmutableArray.Create(
        MSBuildProjectFullPath,
        TargetPath,
        AssemblyName,
        CommandLineArgsForDesignTimeEvaluation);
}


text:
import tarfile

import mock

from nova import test
from nova.virt.xenapi.image import utils

@mock.patch.object(utils, 'IMAGE_API')
class GlanceImageTestCase(test.NoDBTestCase):

    def _get_image(self):
        return utils.GlanceImage(mock.sentinel.context,
                                 mock.sentinel.image_ref)

    def test_meta(self, mocked):
        mocked.get.return_value = mock.sentinel.meta

        image = self._get_image()
        self.assertEqual(mock.sentinel.meta, image.meta)
        mocked.get.assert_called_once_with(mock.sentinel.context,
                                           mock.sentinel.image_ref)

    def test_download_to(self, mocked):
        mocked.download.return_value = None

        image = self._get_image()
        result = image.download_to(mock.sentinel.fobj)
        self.assertIsNone(result)
        mocked.download.assert_called_once_with(mock.sentinel.context,
                                                mock.sentinel.image_ref,
                                                mock.sentinel.fobj)

    def test_is_raw_tgz_empty_meta(self, mocked):
        mocked.get.return_value = {}

        image = self._get_image()
        self.assertFalse(image.is_raw_tgz())

    def test_is_raw_tgz_for_raw_tgz(self, mocked):
        mocked.get.return_value = {
            'disk_format': 'raw',
            'container_format': 'tgz'
        }

        image = self._get_image()
        self.assertTrue(image.is_raw_tgz())

    def test_data(self, mocked):
        mocked.download.return_value = mock.sentinel.image
        image = self._get_image()

        self.assertEqual(mock.sentinel.image, image.data())

class RawImageTestCase(test.NoDBTestCase):
    def test_get_size(self):
        glance_image = self.mox.CreateMock(utils.GlanceImage)
        glance_image.meta = {'size': '123'}
        raw_image = utils.RawImage(glance_image)
        self.mox.ReplayAll()

        self.assertEqual(123, raw_image.get_size())

    def test_stream_to(self):
        glance_image = self.mox.CreateMock(utils.GlanceImage)
        glance_image.download_to('file').AndReturn('result')
        raw_image = utils.RawImage(glance_image)
        self.mox.ReplayAll()

        self.assertEqual('result', raw_image.stream_to('file'))

class TestIterableBasedFile(test.NoDBTestCase):
    def test_constructor(self):
        class FakeIterable(object):
            def __iter__(_self):
                return 'iterator'

        the_file = utils.IterableToFileAdapter(FakeIterable())

        self.assertEqual('iterator', the_file.iterator)

    def test_read_one_character(self):
        the_file = utils.IterableToFileAdapter([
            'chunk1', 'chunk2'
        ])

        self.assertEqual('c', the_file.read(1))

    def test_read_stores_remaining_characters(self):
        the_file = utils.IterableToFileAdapter([
            'chunk1', 'chunk2'
        ])

        the_file.read(1)

        self.assertEqual('hunk1', the_file.remaining_data)

    def test_read_remaining_characters(self):
        the_file = utils.IterableToFileAdapter([
            'chunk1', 'chunk2'
        ])

        self.assertEqual('c', the_file.read(1))
        self.assertEqual('h', the_file.read(1))

    def test_read_reached_end_of_file(self):
        the_file = utils.IterableToFileAdapter([
            'chunk1', 'chunk2'
        ])

        self.assertEqual('chunk1', the_file.read(100))
        self.assertEqual('chunk2', the_file.read(100))
        self.assertEqual('', the_file.read(100))

    def test_empty_chunks(self):
        the_file = utils.IterableToFileAdapter([
            '', '', 'chunk2'
        ])

        self.assertEqual('chunk2', the_file.read(100))

class RawTGZTestCase(test.NoDBTestCase):
    def test_as_tarfile(self):
        image = utils.RawTGZImage(None)
        self.mox.StubOutWithMock(image, '_as_file')
        self.mox.StubOutWithMock(utils.tarfile, 'open')

        image._as_file().AndReturn('the_file')
        utils.tarfile.open(mode='r|gz', fileobj='the_file').AndReturn('tf')

        self.mox.ReplayAll()

        result = image._as_tarfile()
        self.assertEqual('tf', result)

    def test_as_file(self):
        self.mox.StubOutWithMock(utils, 'IterableToFileAdapter')
        glance_image = self.mox.CreateMock(utils.GlanceImage)
        image = utils.RawTGZImage(glance_image)
        glance_image.data().AndReturn('iterable-data')
        utils.IterableToFileAdapter('iterable-data').AndReturn('data-as-file')

        self.mox.ReplayAll()

        result = image._as_file()

        self.assertEqual('data-as-file', result)

    def test_get_size(self):
        tar_file = self.mox.CreateMock(tarfile.TarFile)
        tar_info = self.mox.CreateMock(tarfile.TarInfo)

        image = utils.RawTGZImage(None)

        self.mox.StubOutWithMock(image, '_as_tarfile')

        image._as_tarfile().AndReturn(tar_file)
        tar_file.next().AndReturn(tar_info)
        tar_info.size = 124

        self.mox.ReplayAll()

        result = image.get_size()

        self.assertEqual(124, result)
        self.assertEqual(image._tar_info, tar_info)
        self.assertEqual(image._tar_file, tar_file)

    def test_get_size_called_twice(self):
        tar_file = self.mox.CreateMock(tarfile.TarFile)
        tar_info = self.mox.CreateMock(tarfile.TarInfo)

        image = utils.RawTGZImage(None)

        self.mox.StubOutWithMock(image, '_as_tarfile')

        image._as_tarfile().AndReturn(tar_file)
        tar_file.next().AndReturn(tar_info)
        tar_info.size = 124

        self.mox.ReplayAll()

        image.get_size()
        result = image.get_size()

        self.assertEqual(124, result)
        self.assertEqual(image._tar_info, tar_info)
        self.assertEqual(image._tar_file, tar_file)

    def test_stream_to_without_size_retrieved(self):
        source_tar = self.mox.CreateMock(tarfile.TarFile)
        first_tarinfo = self.mox.CreateMock(tarfile.TarInfo)
        target_file = self.mox.CreateMock(open)
        source_file = self.mox.CreateMock(open)

        image = utils.RawTGZImage(None)
        image._image_service_and_image_id = ('service', 'id')

        self.mox.StubOutWithMock(image, '_as_tarfile', source_tar)
        self.mox.StubOutWithMock(utils.shutil, 'copyfileobj')

        image._as_tarfile().AndReturn(source_tar)
        source_tar.next().AndReturn(first_tarinfo)
        source_tar.extractfile(first_tarinfo).AndReturn(source_file)
        utils.shutil.copyfileobj(source_file, target_file)
        source_tar.close()

        self.mox.ReplayAll()

        image.stream_to(target_file)

    def test_stream_to_with_size_retrieved(self):
        source_tar = self.mox.CreateMock(tarfile.TarFile)
        first_tarinfo = self.mox.CreateMock(tarfile.TarInfo)
        target_file = self.mox.CreateMock(open)
        source_file = self.mox.CreateMock(open)
        first_tarinfo.size = 124

        image = utils.RawTGZImage(None)
        image._image_service_and_image_id = ('service', 'id')

        self.mox.StubOutWithMock(image, '_as_tarfile', source_tar)
        self.mox.StubOutWithMock(utils.shutil, 'copyfileobj')

        image._as_tarfile().AndReturn(source_tar)
        source_tar.next().AndReturn(first_tarinfo)
        source_tar.extractfile(first_tarinfo).AndReturn(source_file)
        utils.shutil.copyfileobj(source_file, target_file)
        source_tar.close()

        self.mox.ReplayAll()

        image.get_size()
        image.stream_to(target_file)


text:
namespace v8 {
namespace internal {

// A set of bit fields representing Smi handlers for loads.
class LoadHandler {
 public:
  enum Kind { kForElements, kForFields, kForConstants };
  class KindBits : public BitField<Kind, 0, 2> {};

  // Defines whether negative lookup check should be done on receiver object.
  // Applicable to kForFields and kForConstants kinds only when loading value
  // from prototype chain. Ignored when loading from holder.
  class DoNegativeLookupOnReceiverBits
      : public BitField<bool, KindBits::kNext, 1> {};

  //
  // Encoding when KindBits contains kForConstants.
  //

  // +2 here is because each descriptor entry occupies 3 slots in array.
  class DescriptorValueIndexBits
      : public BitField<unsigned, DoNegativeLookupOnReceiverBits::kNext,
                        kDescriptorIndexBitCount + 2> {};
  // Make sure we don't overflow the smi.
  STATIC_ASSERT(DescriptorValueIndexBits::kNext <= kSmiValueSize);

  //
  // Encoding when KindBits contains kForFields.
  //
  class IsInobjectBits
      : public BitField<bool, DoNegativeLookupOnReceiverBits::kNext, 1> {};
  class IsDoubleBits : public BitField<bool, IsInobjectBits::kNext, 1> {};
  // +1 here is to cover all possible JSObject header sizes.
  class FieldOffsetBits
      : public BitField<unsigned, IsDoubleBits::kNext,
                        kDescriptorIndexBitCount + 1 + kPointerSizeLog2> {};
  // Make sure we don't overflow the smi.
  STATIC_ASSERT(FieldOffsetBits::kNext <= kSmiValueSize);

  //
  // Encoding when KindBits contains kForElements.
  //
  class IsJsArrayBits : public BitField<bool, KindBits::kNext, 1> {};
  class ConvertHoleBits : public BitField<bool, IsJsArrayBits::kNext, 1> {};
  class ElementsKindBits
      : public BitField<ElementsKind, ConvertHoleBits::kNext, 8> {};
  // Make sure we don't overflow the smi.
  STATIC_ASSERT(ElementsKindBits::kNext <= kSmiValueSize);

  // Creates a Smi-handler for loading a field from fast object.
  static inline Handle<Object> LoadField(Isolate* isolate,
                                         FieldIndex field_index);

  // Creates a Smi-handler for loading a constant from fast object.
  static inline Handle<Object> LoadConstant(Isolate* isolate, int descriptor);

  // Sets DoNegativeLookupOnReceiverBits in given Smi-handler. The receiver
  // check is a part of a prototype chain check.
  static inline Handle<Object> EnableNegativeLookupOnReceiver(
      Isolate* isolate, Handle<Object> smi_handler);

  // Creates a Smi-handler for loading an element.
  static inline Handle<Object> LoadElement(Isolate* isolate,
                                           ElementsKind elements_kind,
                                           bool convert_hole_to_undefined,
                                           bool is_js_array);
};

// A set of bit fields representing Smi handlers for stores.
class StoreHandler {
 public:
  enum Kind { kForElements, kForFields };
  class KindBits : public BitField<Kind, 0, 1> {};

  enum FieldRepresentation { kSmi, kDouble, kHeapObject, kTagged };

  //
  // Encoding when KindBits contains kForFields.
  //
  class IsInobjectBits : public BitField<bool, KindBits::kNext, 1> {};
  class FieldRepresentationBits
      : public BitField<FieldRepresentation, IsInobjectBits::kNext, 2> {};
  // +2 here is because each descriptor entry occupies 3 slots in array.
  class DescriptorValueIndexBits
      : public BitField<unsigned, FieldRepresentationBits::kNext,
                        kDescriptorIndexBitCount + 2> {};
  // +1 here is to cover all possible JSObject header sizes.
  class FieldOffsetBits
      : public BitField<unsigned, DescriptorValueIndexBits::kNext,
                        kDescriptorIndexBitCount + 1 + kPointerSizeLog2> {};
  // Make sure we don't overflow the smi.
  STATIC_ASSERT(FieldOffsetBits::kNext <= kSmiValueSize);

  // Creates a Smi-handler for storing a field to fast object.
  static inline Handle<Object> StoreField(Isolate* isolate, int descriptor,
                                          FieldIndex field_index,
                                          Representation representation);
};

}  // namespace internal
}  // namespace v8

#endif  // V8_IC_HANDLER_CONFIGURATION_H_


text:
package com.luzhishen.easypackage.facade.biz;

import org.springframework.stereotype.Service;

@Service
public class MachineBiz {
    /**
     *
     * @param platformId
     * @return 闲置的PackageWorkerId
     */
    public int getIdleWorker(int platformId) {
        long now = System.currentTimeMillis();
        long minLastHeartBeatTime = now - 60_000;
        /*
         * SELECT * FROM PackageWorker WHERE lastHeartBeatTime > (now - T)
         * UPDATE Platform_PackageWorker SET status=1, facadeIp=getLocalIp(),
         * lockedTime=now WHERE status=0 AND packageWorkerId in ()
         */
        // TODO - implement WorkerBiz.getIdelWorker
        throw new UnsupportedOperationException();
    }

}


text:
using System;
using System.Diagnostics.CodeAnalysis;

namespace NQuery.Compilation
{
	internal abstract class StandardVisitor
	{
		protected StandardVisitor()
		{
		}

		#region Dispatcher

		[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
		[SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling")]
		public virtual AstNode Visit(AstNode node)
		{
			switch (node.NodeType)
			{
				case AstNodeType.Literal:
					return VisitLiteralValue((LiteralExpression)node);

				case AstNodeType.UnaryExpression:
					return VisitUnaryExpression((UnaryExpression)node);
				case AstNodeType.BinaryExpression:
					return VisitBinaryExpression((BinaryExpression)node);
				case AstNodeType.BetweenExpression:
					return VisitBetweenExpression((BetweenExpression)node);
				case AstNodeType.IsNullExpression:
					return VisitIsNullExpression((IsNullExpression)node);
				case AstNodeType.CastExpression:
					return VisitCastExpression((CastExpression)node);
				case AstNodeType.CaseExpression:
					return VisitCaseExpression((CaseExpression)node);
				case AstNodeType.CoalesceExpression:
					return VisitCoalesceExpression((CoalesceExpression)node);
				case AstNodeType.NullIfExpression:
					return VisitNullIfExpression((NullIfExpression)node);
				case AstNodeType.InExpression:
					return VisitInExpression((InExpression)node);

				case AstNodeType.NamedConstantExpression:
					return VisitNamedConstantExpression((NamedConstantExpression)node);
				case AstNodeType.ParameterExpression:
					return VisitParameterExpression((ParameterExpression)node);
				case AstNodeType.NameExpression:
					return VisitNameExpression((NameExpression)node);
				case AstNodeType.PropertyAccessExpression:
					return VisitPropertyAccessExpression((PropertyAccessExpression)node);
				case AstNodeType.FunctionInvocationExpression:
					return VisitFunctionInvocationExpression((FunctionInvocationExpression)node);
				case AstNodeType.MethodInvocationExpression:
					return VisitMethodInvocationExpression((MethodInvocationExpression)node);

				case AstNodeType.ColumnExpression:
					return VisitColumnExpression((ColumnExpression)node);
				case AstNodeType.RowBufferEntryExpression:
					return VisitRowBufferEntryExpression((RowBufferEntryExpression)node);
				case AstNodeType.AggregateExpression:
					return VisitAggregagateExpression((AggregateExpression)node);
				case AstNodeType.SingleRowSubselect:
					return VisitSingleRowSubselect((SingleRowSubselect)node);
				case AstNodeType.ExistsSubselect:
					return VisitExistsSubselect((ExistsSubselect)node);
				case AstNodeType.AllAnySubselect:
					return VisitAllAnySubselect((AllAnySubselect)node);

				case AstNodeType.NamedTableReference:
					return VisitNamedTableReference((NamedTableReference)node);
				case AstNodeType.JoinedTableReference:
					return VisitJoinedTableReference((JoinedTableReference)node);
				case AstNodeType.DerivedTableReference:
					return VisitDerivedTableReference((DerivedTableReference)node);

				case AstNodeType.SelectQuery:
					return VisitSelectQuery((SelectQuery)node);
				case AstNodeType.BinaryQuery:
					return VisitBinaryQuery((BinaryQuery)node);
				case AstNodeType.SortedQuery:
					return VisitSortedQuery((SortedQuery)node);
				case AstNodeType.CommonTableExpressionQuery:
					return VisitCommonTableExpressionQuery((CommonTableExpressionQuery)node);

				case AstNodeType.TableAlgebraNode:
					return VisitTableAlgebraNode((TableAlgebraNode)node);
				case AstNodeType.JoinAlgebraNode:
					return VisitJoinAlgebraNode((JoinAlgebraNode)node);
				case AstNodeType.ConstantScanAlgebraNode:
					return VisitConstantScanAlgebraNode((ConstantScanAlgebraNode)node);
				case AstNodeType.NullScanAlgebraNode:
					return VisitNullScanAlgebraNode((NullScanAlgebraNode)node);
				case AstNodeType.ConcatAlgebraNode:
					return VisitConcatAlgebraNode((ConcatAlgebraNode)node);
				case AstNodeType.SortAlgebraNode:
					return VisitSortAlgebraNode((SortAlgebraNode)node);
				case AstNodeType.AggregateAlgebraNode:
					return VisitAggregateAlgebraNode((AggregateAlgebraNode)node);
				case AstNodeType.TopAlgebraNode:
					return VisitTopAlgebraNode((TopAlgebraNode)node);
				case AstNodeType.FilterAlgebraNode:
					return VisitFilterAlgebraNode((FilterAlgebraNode)node);
				case AstNodeType.ComputeScalarAlgebraNode:
					return VisitComputeScalarAlgebraNode((ComputeScalarAlgebraNode)node);
				case AstNodeType.ResultAlgebraNode:
					return VisitResultAlgebraNode((ResultAlgebraNode)node);
				case AstNodeType.AssertAlgebraNode:
					return VisitAssertAlgebraNode((AssertAlgebraNode)node);
				case AstNodeType.IndexSpoolAlgebraNode:
					return VisitIndexSpoolAlgebraNode((IndexSpoolAlgebraNode)node);
				case AstNodeType.StackedTableSpoolAlgebraNode:
					return VisitStackedTableSpoolAlgebraNode((StackedTableSpoolAlgebraNode)node);
				case AstNodeType.StackedTableSpoolRefAlgebraNode:
					return VisitTableSpoolRefAlgebraNode((StackedTableSpoolRefAlgebraNode)node);
				case AstNodeType.HashMatchAlgebraNode:
					return VisitHashMatchAlgebraNode((HashMatchAlgebraNode)node);

				default:
					throw ExceptionBuilder.UnhandledCaseLabel(node.NodeType);
			}
		}

		#endregion

		#region Expressions

		public virtual ExpressionNode VisitExpression(ExpressionNode expression)
		{
			return (ExpressionNode)Visit(expression);
		}

		#region Literal Expression

		public virtual LiteralExpression VisitLiteralValue(LiteralExpression expression)
		{
			return expression;
		}

		#endregion

		#region Compound Expressions

		public virtual ExpressionNode VisitUnaryExpression(UnaryExpression expression)
		{
			expression.Operand = VisitExpression(expression.Operand);
			return expression;
		}

		public virtual ExpressionNode VisitBinaryExpression(BinaryExpression expression)
		{
			expression.Left = VisitExpression(expression.Left);
			expression.Right = VisitExpression(expression.Right);
			return expression;
		}

		public virtual ExpressionNode VisitBetweenExpression(BetweenExpression expression)
		{
			expression.Expression = VisitExpression(expression.Expression);
			expression.LowerBound = VisitExpression(expression.LowerBound);
			expression.UpperBound = VisitExpression(expression.UpperBound);
			return expression;
		}

		public virtual ExpressionNode VisitIsNullExpression(IsNullExpression expression)
		{
			expression.Expression = VisitExpression(expression.Expression);
			return expression;
		}

		public virtual ExpressionNode VisitCastExpression(CastExpression expression)
		{
			expression.Expression = VisitExpression(expression.Expression);
			return expression;
		}

		public virtual ExpressionNode VisitCaseExpression(CaseExpression expression)
		{
			if (expression.InputExpression != null)
				expression.InputExpression = VisitExpression(expression.InputExpression);

			for (int i = 0; i < expression.WhenExpressions.Length; i++)
				expression.WhenExpressions[i] = VisitExpression(expression.WhenExpressions[i]);

			for (int i = 0; i < expression.ThenExpressions.Length; i++)
				expression.ThenExpressions[i] = VisitExpression(expression.ThenExpressions[i]);

			if (expression.ElseExpression != null)
				expression.ElseExpression = VisitExpression(expression.ElseExpression);

			return expression;
		}

		public virtual ExpressionNode VisitCoalesceExpression(CoalesceExpression expression)
		{
			for (int i = 0; i < expression.Expressions.Length; i++)
				expression.Expressions[i] = VisitExpression(expression.Expressions[i]);

			return expression;
		}

		public virtual ExpressionNode VisitNullIfExpression(NullIfExpression expression)
		{
			expression.LeftExpression = VisitExpression(expression.LeftExpression);
			expression.RightExpression = VisitExpression(expression.RightExpression);
			return expression;
		}

		public virtual ExpressionNode VisitInExpression(InExpression expression)
		{
			for (int i = 0; i < expression.RightExpressions.Length; i++)
				expression.RightExpressions[i] = VisitExpression(expression.RightExpressions[i]);

			return expression;
		}

		#endregion

		#region Referencing Expression

		public virtual ExpressionNode VisitNamedConstantExpression(NamedConstantExpression expression)
		{
			return expression;
		}

		public virtual ExpressionNode VisitParameterExpression(ParameterExpression expression)
		{
			return expression;
		}

		public virtual ExpressionNode VisitNameExpression(NameExpression expression)
		{
			return expression;
		}

		public virtual ExpressionNode VisitPropertyAccessExpression(PropertyAccessExpression expression)
		{
			expression.Target = VisitExpression(expression.Target);
			return expression;
		}

		public virtual ExpressionNode VisitFunctionInvocationExpression(FunctionInvocationExpression expression)
		{
			for (int i = 0; i < expression.Arguments.Length; i++)
				expression.Arguments[i] = VisitExpression(expression.Arguments[i]);
			return expression;
		}

		public virtual ExpressionNode VisitMethodInvocationExpression(MethodInvocationExpression expression)
		{
			expression.Target = VisitExpression(expression.Target);
			for (int i = 0; i < expression.Arguments.Length; i++)
				expression.Arguments[i] = VisitExpression(expression.Arguments[i]);
			return expression;
		}

		#endregion

		#region Query Expressions

		public virtual ExpressionNode VisitColumnExpression(ColumnExpression expression)
		{
			return expression;
		}

		public virtual ExpressionNode VisitRowBufferEntryExpression(RowBufferEntryExpression expression)
		{
			return expression;
		}

		public virtual ExpressionNode VisitAggregagateExpression(AggregateExpression expression)
		{
			expression.Argument = VisitExpression(expression.Argument);
			return expression;
		}

		public virtual ExpressionNode VisitSingleRowSubselect(SingleRowSubselect expression)
		{
			expression.Query = VisitQuery(expression.Query);
			return expression;
		}

		public virtual ExpressionNode VisitExistsSubselect(ExistsSubselect expression)
		{
			expression.Query = VisitQuery(expression.Query);
			return expression;
		}

		public virtual ExpressionNode VisitAllAnySubselect(AllAnySubselect expression)
		{
			expression.Left = VisitExpression(expression.Left);
			expression.Query = VisitQuery(expression.Query);
			return expression;
		}

		#endregion

		#endregion

		#region Query

		public virtual TableReference VisitTableReference(TableReference node)
		{
			return (TableReference)Visit(node);
		}

		public virtual TableReference VisitNamedTableReference(NamedTableReference node)
		{
			return node;
		}

		public virtual TableReference VisitJoinedTableReference(JoinedTableReference node)
		{
			node.Left = VisitTableReference(node.Left);
			node.Right = VisitTableReference(node.Right);

			if (node.Condition != null)
				node.Condition = VisitExpression(node.Condition);
			return node;
		}

		public virtual TableReference VisitDerivedTableReference(DerivedTableReference node)
		{
			node.Query = VisitQuery(node.Query);
			return node;
		}

		public virtual QueryNode VisitQuery(QueryNode query)
		{
			return (QueryNode)Visit(query);
		}

		public virtual QueryNode VisitSelectQuery(SelectQuery query)
		{
			// Visit all column expressions

			for (int i = 0; i < query.SelectColumns.Length; i++)
			{
				if (query.SelectColumns[i].Expression != null)
					query.SelectColumns[i].Expression = VisitExpression(query.SelectColumns[i].Expression);
			}

			// Visit FROM table references

			if (query.TableReferences != null)
				query.TableReferences = VisitTableReference(query.TableReferences);

			// Visit WHERE expression

			if (query.WhereClause != null)
				query.WhereClause = VisitExpression(query.WhereClause);

			// Visit GROUP BY clause

			if (query.GroupByColumns != null)
			{
				for (int i = 0; i < query.GroupByColumns.Length; i++)
					query.GroupByColumns[i] = VisitExpression(query.GroupByColumns[i]);
			}

			if (query.HavingClause != null)
				query.HavingClause = VisitExpression(query.HavingClause);

			// Visit ORDER BY expressions

			if (query.OrderByColumns != null)
			{
				for (int i = 0; i < query.OrderByColumns.Length; i++)
					query.OrderByColumns[i].Expression = VisitExpression(query.OrderByColumns[i].Expression);
			}

			return query;
		}

		public virtual QueryNode VisitBinaryQuery(BinaryQuery query)
		{
			query.Left = VisitQuery(query.Left);
			query.Right = VisitQuery(query.Right);
			return query;
		}

		public virtual QueryNode VisitSortedQuery(SortedQuery query)
		{
			// Visit input
			query.Input = VisitQuery(query.Input);

			// Visit ORDER BY expressions

			if (query.OrderByColumns != null)
			{
				for (int i = 0; i < query.OrderByColumns.Length; i++)
					query.OrderByColumns[i].Expression = VisitExpression(query.OrderByColumns[i].Expression);
			}

			return query;
		}

		public virtual QueryNode VisitCommonTableExpressionQuery(CommonTableExpressionQuery query)
		{
			foreach (CommonTableExpression commonTableExpression in query.CommonTableExpressions)
				commonTableExpression.QueryDeclaration = VisitQuery(commonTableExpression.QueryDeclaration);

			query.Input = VisitQuery(query.Input);
			return query;
		}

		#endregion

		#region Algebra Nodes

		public virtual AlgebraNode VisitAlgebraNode(AlgebraNode node)
		{
			return (AlgebraNode)Visit(node);
		}

		public virtual AlgebraNode VisitTableAlgebraNode(TableAlgebraNode node)
		{
			return node;
		}

		public virtual AlgebraNode VisitJoinAlgebraNode(JoinAlgebraNode node)
		{
			node.Left = VisitAlgebraNode(node.Left);
			node.Right = VisitAlgebraNode(node.Right);

			if (node.Predicate != null)
				node.Predicate = VisitExpression(node.Predicate);

			if (node.PassthruPredicate != null)
				node.PassthruPredicate = VisitExpression(node.PassthruPredicate);

			return node;
		}

		public virtual AlgebraNode VisitConstantScanAlgebraNode(ConstantScanAlgebraNode node)
		{
			if (node.DefinedValues != null)
			{
				foreach (ComputedValueDefinition definedValue in node.DefinedValues)
					definedValue.Expression = VisitExpression(definedValue.Expression);
			}

			return node;
		}

		public virtual AlgebraNode VisitNullScanAlgebraNode(NullScanAlgebraNode node)
		{
			return node;
		}

		public virtual AlgebraNode VisitConcatAlgebraNode(ConcatAlgebraNode node)
		{
			for (int i = 0; i < node.Inputs.Length; i++)
				node.Inputs[i] = VisitAlgebraNode(node.Inputs[i]);

			return node;
		}

		public virtual AlgebraNode VisitSortAlgebraNode(SortAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			return node;
		}

		public virtual AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);

			if (node.DefinedValues != null)
			{
				foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
					definedValue.Argument = VisitExpression(definedValue.Argument);
			}

			return node;
		}

		public virtual AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			return node;
		}

		public virtual AlgebraNode VisitFilterAlgebraNode(FilterAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			node.Predicate = VisitExpression(node.Predicate);

			return node;
		}

		public virtual AlgebraNode VisitComputeScalarAlgebraNode(ComputeScalarAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);

			if (node.DefinedValues != null)
			{
				foreach (ComputedValueDefinition definedValue in node.DefinedValues)
					definedValue.Expression = VisitExpression(definedValue.Expression);
			}

			return node;
		}

		public virtual AlgebraNode VisitResultAlgebraNode(ResultAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			return node;
		}

		public virtual AlgebraNode VisitAssertAlgebraNode(AssertAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			node.Predicate = VisitExpression(node.Predicate);
			return node;
		}

		public virtual AlgebraNode VisitIndexSpoolAlgebraNode(IndexSpoolAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			return node;
		}

		public virtual AstNode VisitStackedTableSpoolAlgebraNode(StackedTableSpoolAlgebraNode node)
		{
			node.Input = VisitAlgebraNode(node.Input);
			return node;
		}

		public virtual AstNode VisitTableSpoolRefAlgebraNode(StackedTableSpoolRefAlgebraNode node)
		{
			return node;
		}

		public virtual AlgebraNode VisitHashMatchAlgebraNode(HashMatchAlgebraNode node)
		{
			node.Left = VisitAlgebraNode(node.Left);
			node.Right = VisitAlgebraNode(node.Right);

			if (node.ProbeResidual != null)
				node.ProbeResidual = VisitExpression(node.ProbeResidual);

			return node;
		}

		#endregion
	}
}