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.
#
BuildrPlus::FeatureManager.feature(:java => [:ruby]) do |f|
  f.enhance(:Config) do
    def version=(version)
      raise "Invalid java version #{version}" unless [7, 8].include?(version)
      @version = version
    end

    def version
      @version || 8
    end

    attr_writer :enable_annotation_processor

    def enable_annotation_processor?
      @enable_annotation_processor.nil? ? true : !!@enable_annotation_processor
    end
  end
  f.enhance(:ProjectExtension) do
    attr_writer :enable_annotation_processor

    def enable_annotation_processor?
      @enable_annotation_processor.nil? ? BuildrPlus::Java.enable_annotation_processor? : !!@enable_annotation_processor
    end

    before_define do |project|
      project.compile.options.lint = 'all'
      project.compile.options.source = "1.#{BuildrPlus::Java.version}"
      project.compile.options.target = "1.#{BuildrPlus::Java.version}"
      project.iml.instance_variable_set('@main_generated_source_directories',[])
    end

    after_define do |project|
      project.test.options[:properties].merge!('user.timezone' => 'Australia/Melbourne')

      t = project.task 'java:check' do
        (project.test.compile.sources + project.compile.sources).each do |src|
          Dir.glob("#{src}/**/*").select {|f| File.directory? f}.each do |d|
            dir = d[src.size + 1, 10000000]
            if dir.include?('.')
              raise "The directory #{d} included in java source path has a path component that includes the '.' character. This violates package name conventions."
            end
          end
        end
      end
      project.task(':java:check').enhance([t.name])

      if project.iml? && project.enable_annotation_processor?
        project.iml.main_generated_source_directories << project._('generated/processors/main/java')
      end

      if project.ipr? && BuildrPlus::Java.enable_annotation_processor?
        project.ipr.add_component('CompilerConfiguration') do |component|
          component.annotationProcessing do |xml|
            xml.profile(:default => true, :name => 'Default', :enabled => true) do
              xml.sourceOutputDir :name => 'generated/processors/main/java'
              xml.sourceTestOutputDir :name => 'generated/processors/test/java'
              xml.outputRelativeToContentRoot :value => true
            end
            disabled = Buildr.projects(:no_invoke => true).select {|p| p.iml? && !p.enable_annotation_processor?}
            unless disabled.empty?
              xml.profile(:name => 'Disabled') do
                disabled.each do |p|
                  xml.module :name => p.name
                end
              end
            end
          end
        end
      end
    end

    desc 'Check the directories in java source tree do not have . character'
    task 'java:check'
  end
end


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

#include "config.h"

#include <functional>
#include <list>
#include <string>

#include "ep_engine.h"
#define STATWRITER_NAMESPACE vbucket
#include "statwriter.h"
#undef STATWRITER_NAMESPACE
#include "vbucket.h"

VBucketFilter VBucketFilter::filter_diff(const VBucketFilter &other) const {
    std::vector<uint16_t> tmp(acceptable.size() + other.size());
    std::vector<uint16_t>::iterator end;
    end = std::set_symmetric_difference(acceptable.begin(),
                                        acceptable.end(),
                                        other.acceptable.begin(),
                                        other.acceptable.end(),
                                        tmp.begin());
    return VBucketFilter(std::vector<uint16_t>(tmp.begin(), end));
}

VBucketFilter VBucketFilter::filter_intersection(const VBucketFilter &other) const {
    std::vector<uint16_t> tmp(acceptable.size() + other.size());
    std::vector<uint16_t>::iterator end;

    end = std::set_intersection(acceptable.begin(), acceptable.end(),
                                other.acceptable.begin(), other.acceptable.end(),
                                tmp.begin());
    return VBucketFilter(std::vector<uint16_t>(tmp.begin(), end));
}

static bool isRange(std::set<uint16_t>::const_iterator it,
                    const std::set<uint16_t>::const_iterator &end,
                    size_t &length)
{
    length = 0;
    for (uint16_t val = *it;
         it != end && (val + length) == *it;
         ++it, ++length) {
        // empty
    }

    --length;

    return length > 1;
}

std::ostream& operator <<(std::ostream &out, const VBucketFilter &filter)
{
    std::set<uint16_t>::const_iterator it;

    if (filter.acceptable.empty()) {
        out << "{ empty }";
    } else {
        bool needcomma = false;
        out << "{ ";
        for (it = filter.acceptable.begin();
             it != filter.acceptable.end();
             ++it) {
            if (needcomma) {
                out << ", ";
            }

            size_t length;
            if (isRange(it, filter.acceptable.end(), length)) {
                std::set<uint16_t>::iterator last = it;
                for (size_t i = 0; i < length; ++i) {
                    ++last;
                }
                out << "[" << *it << "," << *last << "]";
                it = last;
            } else {
                out << *it;
            }
            needcomma = true;
        }
        out << " }";
    }

    return out;
}

size_t VBucket::chkFlushTimeout = MIN_CHK_FLUSH_TIMEOUT;

const vbucket_state_t VBucket::ACTIVE = static_cast<vbucket_state_t>(htonl(vbucket_state_active));
const vbucket_state_t VBucket::REPLICA = static_cast<vbucket_state_t>(htonl(vbucket_state_replica));
const vbucket_state_t VBucket::PENDING = static_cast<vbucket_state_t>(htonl(vbucket_state_pending));
const vbucket_state_t VBucket::DEAD = static_cast<vbucket_state_t>(htonl(vbucket_state_dead));

void VBucket::fireAllOps(EventuallyPersistentEngine &engine, ENGINE_ERROR_CODE code) {
    if (pendingOpsStart > 0) {
        hrtime_t now = gethrtime();
        if (now > pendingOpsStart) {
            hrtime_t d = (now - pendingOpsStart) / 1000;
            stats.pendingOpsHisto.add(d);
            stats.pendingOpsMaxDuration.setIfBigger(d);
        }
    } else {
        return;
    }

    pendingOpsStart = 0;
    stats.pendingOps.decr(pendingOps.size());
    stats.pendingOpsMax.setIfBigger(pendingOps.size());

    engine.notifyIOComplete(pendingOps, code);
    pendingOps.clear();

    LOG(EXTENSION_LOG_INFO,
        "Fired pendings ops for vbucket %d in state %s\n",
        id, VBucket::toString(state));
}

void VBucket::fireAllOps(EventuallyPersistentEngine &engine) {
    LockHolder lh(pendingOpLock);

    if (state == vbucket_state_active) {
        fireAllOps(engine, ENGINE_SUCCESS);
    } else if (state == vbucket_state_pending) {
        // Nothing
    } else {
        fireAllOps(engine, ENGINE_NOT_MY_VBUCKET);
    }
}

void VBucket::setState(vbucket_state_t to, SERVER_HANDLE_V1 *sapi) {
    assert(sapi);
    vbucket_state_t oldstate(state);

    if (to == vbucket_state_active && checkpointManager.getOpenCheckpointId() < 2) {
        checkpointManager.setOpenCheckpointId(2);
    }

    LOG(EXTENSION_LOG_DEBUG, "transitioning vbucket %d from %s to %s",
        id, VBucket::toString(oldstate), VBucket::toString(to));

    state = to;
}

void VBucket::doStatsForQueueing(QueuedItem& qi, size_t itemBytes)
{
    ++dirtyQueueSize;
    dirtyQueueMem.incr(sizeof(QueuedItem));
    ++dirtyQueueFill;
    dirtyQueueAge.incr(qi.getQueuedTime());
    dirtyQueuePendingWrites.incr(itemBytes);
}

void VBucket::doStatsForFlushing(QueuedItem& qi, size_t itemBytes)
{
    if (dirtyQueueSize > 0) {
        --dirtyQueueSize;
    }
    if (dirtyQueueMem > sizeof(QueuedItem)) {
        dirtyQueueMem.decr(sizeof(QueuedItem));
    } else {
        dirtyQueueMem.set(0);
    }
    ++dirtyQueueDrain;

    if (dirtyQueueAge > qi.getQueuedTime()) {
        dirtyQueueAge.decr(qi.getQueuedTime());
    } else {
        dirtyQueueAge.set(0);
    }

    if (dirtyQueuePendingWrites > itemBytes) {
        dirtyQueuePendingWrites.decr(itemBytes);
    } else {
        dirtyQueuePendingWrites.set(0);
    }
}

void VBucket::resetStats() {
    opsCreate.set(0);
    opsUpdate.set(0);
    opsDelete.set(0);
    opsReject.set(0);

    stats.diskQueueSize.decr(dirtyQueueSize.get());
    assert(stats.diskQueueSize < GIGANTOR);
    dirtyQueueSize.set(0);
    dirtyQueueMem.set(0);
    dirtyQueueFill.set(0);
    dirtyQueueAge.set(0);
    dirtyQueuePendingWrites.set(0);
    dirtyQueueDrain.set(0);
}

template <typename T>
void VBucket::addStat(const char *nm, T val, ADD_STAT add_stat, const void *c) {
    std::stringstream name;
    name << "vb_" << id;
    if (nm != NULL) {
        name << ":" << nm;
    }
    std::stringstream value;
    value << val;
    std::string n = name.str();
    add_casted_stat(n.data(), value.str().data(), add_stat, c);
}

void VBucket::queueBGFetchItem(VBucketBGFetchItem *fetch,
                               BgFetcher *bgFetcher, bool notify) {
    LockHolder lh(pendingBGFetchesLock);
    pendingBGFetches.push(fetch);
    lh.unlock();
    if (notify) {
        bgFetcher->notifyBGEvent();
    }
}

bool VBucket::getBGFetchItems(vb_bgfetch_queue_t &fetches) {
    LockHolder lh(pendingBGFetchesLock);
    while (!pendingBGFetches.empty()) {
        VBucketBGFetchItem *it = pendingBGFetches.front();
        fetches[it->value.getId()].push_back(it);
        pendingBGFetches.pop();
    }
    return fetches.size() > 0;
}

void VBucket::addHighPriorityVBEntry(uint64_t chkid, const void *cookie) {
    LockHolder lh(hpChksMutex);
    hpChks.push_back(HighPriorityVBEntry(cookie, chkid));
    ++stats.highPriorityChks;
}

void VBucket::notifyCheckpointPersisted(EventuallyPersistentEngine &e,
                                        uint64_t chkid) {
    LockHolder lh(hpChksMutex);
    std::list<HighPriorityVBEntry>::iterator entry = hpChks.begin();
    while (entry != hpChks.end()) {
        hrtime_t wall_time(gethrtime() - entry->start);
        size_t spent = wall_time / 1000000000;
        if (entry->checkpoint <= chkid) {
            e.notifyIOComplete(entry->cookie, ENGINE_SUCCESS);
            stats.chkPersistenceHisto.add(wall_time / 1000);
            adjustCheckpointFlushTimeout(wall_time / 1000000000);
            LOG(EXTENSION_LOG_WARNING, "Notified the completion of checkpoint "
                "persistence for vbucket %d, cookie %p", id, entry->cookie);
            entry = hpChks.erase(entry);
            --stats.highPriorityChks;
        } else if (spent > getCheckpointFlushTimeout()) {
            e.notifyIOComplete(entry->cookie, ENGINE_TMPFAIL);
            adjustCheckpointFlushTimeout(spent);
            LOG(EXTENSION_LOG_WARNING, "Notified the timeout on checkpoint "
                "persistence for vbucket %d, cookie %p", id, entry->cookie);
            entry = hpChks.erase(entry);
            --stats.highPriorityChks;
        } else {
            ++entry;
        }
    }
}

void VBucket::adjustCheckpointFlushTimeout(size_t wall_time) {
    size_t middle = (MIN_CHK_FLUSH_TIMEOUT + MAX_CHK_FLUSH_TIMEOUT) / 2;

    if (wall_time <= MIN_CHK_FLUSH_TIMEOUT) {
        chkFlushTimeout = MIN_CHK_FLUSH_TIMEOUT;
    } else if (wall_time <= middle) {
        chkFlushTimeout = middle;
    } else {
        chkFlushTimeout = MAX_CHK_FLUSH_TIMEOUT;
    }
}

size_t VBucket::getHighPriorityChkSize() const {
    return hpChks.size();
}

size_t VBucket::getCheckpointFlushTimeout() {
    return chkFlushTimeout;
}

void VBucket::addStats(bool details, ADD_STAT add_stat, const void *c) {
    addStat(NULL, toString(state), add_stat, c);
    if (details) {
        size_t numItems = ht.getNumItems();
        size_t tempItems = ht.getNumTempItems();
        addStat("num_items", numItems, add_stat, c);
        addStat("num_temp_items", tempItems, add_stat, c);
        addStat("num_non_resident", ht.getNumNonResidentItems(), add_stat, c);
        addStat("ht_memory", ht.memorySize(), add_stat, c);
        addStat("ht_item_memory", ht.getItemMemory(), add_stat, c);
        addStat("ht_cache_size", ht.cacheSize, add_stat, c);
        addStat("num_ejects", ht.getNumEjects(), add_stat, c);
        addStat("ops_create", opsCreate, add_stat, c);
        addStat("ops_update", opsUpdate, add_stat, c);
        addStat("ops_delete", opsDelete, add_stat, c);
        addStat("ops_reject", opsReject, add_stat, c);
        addStat("queue_size", dirtyQueueSize, add_stat, c);
        addStat("queue_memory", dirtyQueueMem, add_stat, c);
        addStat("queue_fill", dirtyQueueFill, add_stat, c);
        addStat("queue_drain", dirtyQueueDrain, add_stat, c);
        addStat("queue_age", getQueueAge(), add_stat, c);
        addStat("pending_writes", dirtyQueuePendingWrites, add_stat, c);
    }
}

redpajama_set_name: RedPajamaGithub


text:
'use strict';

$(function () {
    // for responsive headline
    jQuery("#headline").fitText();

    // cache
    var todoForm = $('#todo-form');
    var todoText = $("#todo-text");
    var todoItemsInProgress = $('ul#todo-items-in-progress');
    var todoItemsDone = $('ul#todo-items-done');

    // init
    $('li').each(function() {
        registerChange($(this));
    });

    // react to adding items
    todoForm.submit(function (event) {
        event.preventDefault();

        if (todoText.val() != "") {

            // set input box readonly while waiting for request
            todoText.attr('readonly', 'readonly');

            addItem(
                todoText.val(),
                function (data) {       // done
                    addHtml(todoText.val(), data.id);
                    todoText.val("");
                },
                function (jqXHR) {      // fail
                    console.log("error: %o", jqXHR);
                },
                function() {            // always
                    todoText.removeAttr('readonly');
                }
            );
        }
    });

    function addHtml(text, id, isDone) {
        // decide which list item is going
        var list = (isDone ? todoItemsDone : todoItemsInProgress);

        // make and insert item
        list.append(
            "
" +
                "
" +
                    "<input id=\"checkbox" + id + "\" type=\"checkbox\" " + (isDone ? "checked=\"checked\"" : "") + "> " +
                    "" +
                        text +
                    "" +
                    "
" +
                        "" +
                    "
" +
                "
" +
            "
"
        );

        // register for events
        registerChange($("li[data-id=" + id + "]"));
    }

    function registerChange(that) {
        var li = that;

        // checkbox
        $('input', li).click(function() {
            var input = $(this);
            var checked = input.prop("checked");

            console.log("%i changed to %o", li.data('id'), checked);

            // move item to another list
            if(checked) {
                li.addClass("disabled");
                li.detach().appendTo(todoItemsDone);
            } else {
                li.removeClass("disabled");
                li.detach().appendTo(todoItemsInProgress);
            }

            // add spinner
            $(".pull-right", li).html("");

            toggleItem(
                li.data('id'),
                function() {            // done
                    // remove spinner
                    $(".pull-right", li).html("");
                },
                function(jqXHR) {       // fail
                    // replace spinner with error icon
                    $('i', li).removeClass('fa-refresh fa-spin').addClass('fa-ban text-danger');

                    // return to previous state
                    input.prop("checked", "checked");

                    if(!checked) {
                        li.addClass("disabled");
                        li.detach().appendTo(todoItemsDone);
                    } else {
                        li.removeClass("disabled");
                        li.detach().appendTo(todoItemsInProgress);
                    }

                    console.log("error: %o", jqXHR);
                }
            );
        });

        // link for deleting
        $("a", li).click(function (event) {
            event.preventDefault();

            console.log("trying to delete %i", li.data('id'));

            // add spinner
            $(".pull-right", li).html("");

            deleteItem(
                li.data('id'),
                function() {            // done
                    // remove element from dom
                    li.remove();
                },
                function (jqXHR) {      // fail
                    $('i', li).removeClass('fa-refresh fa-spin').addClass('fa-ban text-danger');
                    console.log("error: %o", jqXHR);
                }
            );
        });
    }

    //
    // functions for communicating with backend
    //

    function getItems(done, fail, always) {
        $.ajax({
            type: "GET",
            url: BASEURL + "/api/items",
            dataType: "json"
        })
            .done(done)      // data, textStatus, jqXHR
            .fail(fail)      // jqXHR, textStatus, errorThrown
            .always(always); // data|jqXHR, textStatus, jqXHR|errorThrown
    }

    function addItem(text, done, fail, always) {
        $.ajax({
            type: "PUT",
            url: BASEURL + "/api/items/add",
            dataType: "json",
            data: {
                "text": text
            }
        })
            .done(done)
            .fail(fail)
            .always(always);
    }

    function toggleItem(id, done, fail, always) {
        $.ajax({
            type: "POST",
            url: BASEURL + "/api/items/toggle",
            dataType: "json",
            data: {
                "id": id
            }
        })
            .done(done)
            .fail(fail)
            .always(always);
    }

    function deleteItem(id, done, fail, always) {
        $.ajax({
            type: "DELETE",
            url: BASEURL + "/api/items/delete",
            dataType: "json",
            data: {
                "id": id
            }
        })
            .done(done)
            .fail(fail)
            .always(always);
    }
});


text:
using System.Collections.Generic;
using OpenSim.Services.Interfaces;

namespace Aurora.Framework
{
    public interface IGridRegisterModule
    {
        /// <summary>
        ///   Update the grid server with new info about this region
        /// </summary>
        /// <param name = "scene"></param>
        void UpdateGridRegion(IScene scene);

        /// <summary>
        ///   Register this region with the grid service
        /// </summary>
        /// <param name = "scene"></param>
        /// <param name = "returnResultImmediately">If false, it will walk the user through how to fix potential issues</param>
        /// <param name = "continueTrying">Continue trying to register until it succeeds</param>
        /// <param name="password"> </param>
        /// <returns>Success</returns>
        bool RegisterRegionWithGrid(IScene scene, bool returnResultImmediately, bool continueTrying, string password);

        /// <summary>
        ///   Add this generic info to all registering regions
        /// </summary>
        /// <param name="key"> </param>
        /// <param name="value"> </param>
        void AddGenericInfo(string key, string value);

        /// <summary>
        ///   Get the neighbors of the given region
        /// </summary>
        /// <param name = "scene"></param>
        /// <returns></returns>
        List<GridRegion> GetNeighbors(IScene scene);
    }
}


text:
import sys
import getopt
import requests
import json

# to print non-ascii string
reload(sys)
sys.setdefaultencoding('utf-8')

API_KEY = "h8VzXEBGrbBB06YFtVsdSKGG"
URL = "http://openapi.baidu.com/public/2.0/translate/dict/simple"

def get_response(word):
    """ Fetch translate result from baidu api
    Args:
        word(str): query word
    Returns:
        (requests.models.Response): response object
    """
    url = URL + "?client_id=" + API_KEY + "&q=" + word + "&from=en&to=zh"
    return requests.get(url)

def print_res(data):
    """ Print translate result in a better format
    Args:
        data(str): result
    """
    print('===================================')
    main_part = data['data']
    print(main_part['word_name'])
    symbols = main_part['symbols'][0]
    print("美式音标:[" + symbols['ph_am'] + "]")
    print("英式音标:[" + symbols['ph_en'] + "]")
    print('-----------------------------------')
    parts = symbols['parts']
    for part in parts:
        print(part['part'])
        for mean in part['means']:
            print("    ", mean)
    print('===================================')

def main():
    print("Translating...")
    try:
        opts, args = getopt.getopt(sys.argv[1:], "h", ["help"])
    except getopt.GetoptError as err:
        print(str(err))
        sys.exit(2)

    if len(args) == 0:
        print("Need a word to be translated. ")
        sys.exit(2)

    word = " ".join(args).lower()
    data = json.loads(get_response(word).text)
    if len(data['data']) == 0:
        # if word doesn't exist
        print("Not a valid word. ")
        sys.exit(2)
    print_res(data)

if __name__ == "__main__":
    main()


text:
Personal Genome Project Data
============================

This dataset comprises roughly 180 Complete Genomics genomes.  See the `Personal Genome Project`_ and the publication for full details:

|  `A public resource facilitating clinical use of genomes <http://www.ncbi.nlm.nih.gov/pubmed/22797899>`_
|  Ball MP1, Thakuria JV, Zaranek AW, Clegg T, Rosenbaum AM, Wu X, Angrist M, Bhak J, Bobe J, Callow MJ, Cano C, Chou MF, Chung WK, Douglas SM, Estep PW, Gore A, Hulick P, Labarga A, Lee JH, Lunshof JE, Kim BC, Kim JI, Li Z, Murray MF, Nilsen GB, Peters BA, Raman AM, Rienhoff HY, Robasky K, Wheeler MT, Vandewege W, Vorhaus DB, Yang JL, Yang L, Aach J, Ashley EA, Drmanac R, Kim SJ, Li JB, Peshkin L, Seidman CE, Seo JS, Zhang K, Rehm HL, Church GM.
|  Published: July 24, 2012
|  DOI: 10.1073/pnas.1201904109
|

Google Cloud Platform data locations
------------------------------------

* Google Cloud Storage folder `gs://pgp-harvard-data-public <https://console.developers.google.com/storage/pgp-harvard-data-public>`_
* Google Genomics Dataset ID `9170389916365079788 <https://developers.google.com/apis-explorer/#p/genomics/v1beta2/genomics.datasets.get?datasetId=9170389916365079788>`_
* Google BigQuery Dataset IDs
   * `google.com:biggene:pgp_20150205.variants <https://bigquery.cloud.google.com/table/google.com:biggene:pgp_20150205.variants>`_
   * `google.com:biggene:pgp_20150205.variants_cgi_only <https://bigquery.cloud.google.com/table/google.com:biggene:pgp_20150205.variants_cgi_only>`_ where the export excluded the single variants-only Illumina genome

Provenance
----------

Google Genomics variant set for dataset ``pgp_20150205``: `9170389916365079788 <https://developers.google.com/apis-explorer/#p/genomics/v1beta2/genomics.datasets.get?datasetId=9170389916365079788>`_ contains:

* the Complete Genomics datasets from `gs://pgp-harvard-data-public/**/masterVar*bz2 <https://console.developers.google.com/storage/pgp-harvard-data-public>`_
* a few additional `PGP`_ Complete Genomics genomes
* and one `PGP`_ variants-only Illumina genome

Appendix
--------
.. include:: /pgp-data.rst


text:
class PrefService;

namespace chromecast {
namespace shell {
class CastNetworkContexts;
}  // namespace shell
}  // namespace chromecast

namespace extensions {

class ExtensionsAPIClient;

// An ExtensionsBrowserClient that supports a single content::BrowserContent
// with no related incognito context.
class CastExtensionsBrowserClient : public ExtensionsBrowserClient {
 public:
  // |context| is the single BrowserContext used for IsValidContext() below.
  // |pref_service| is used for GetPrefServiceForContext() below.
  CastExtensionsBrowserClient(
      content::BrowserContext* context,
      PrefService* pref_service,
      chromecast::shell::CastNetworkContexts* cast_network_contexts);

  CastExtensionsBrowserClient(const CastExtensionsBrowserClient&) = delete;
  CastExtensionsBrowserClient& operator=(const CastExtensionsBrowserClient&) =
      delete;

  ~CastExtensionsBrowserClient() override;

  // ExtensionsBrowserClient overrides:
  network::mojom::NetworkContext* GetSystemNetworkContext() override;
  bool IsShuttingDown() override;
  bool AreExtensionsDisabled(const base::CommandLine& command_line,
                             content::BrowserContext* context) override;
  bool IsValidContext(content::BrowserContext* context) override;
  bool IsSameContext(content::BrowserContext* first,
                     content::BrowserContext* second) override;
  bool HasOffTheRecordContext(content::BrowserContext* context) override;
  content::BrowserContext* GetOffTheRecordContext(
      content::BrowserContext* context) override;
  content::BrowserContext* GetOriginalContext(
      content::BrowserContext* context) override;
  bool IsGuestSession(content::BrowserContext* context) const override;
  bool IsExtensionIncognitoEnabled(
      const std::string& extension_id,
      content::BrowserContext* context) const override;
  bool CanExtensionCrossIncognito(
      const Extension* extension,
      content::BrowserContext* context) const override;
  base::FilePath GetBundleResourcePath(
      const network::ResourceRequest& request,
      const base::FilePath& extension_resources_path,
      int* resource_id) const override;
  void LoadResourceFromResourceBundle(
      const network::ResourceRequest& request,
      mojo::PendingReceiver<network::mojom::URLLoader> loader,
      const base::FilePath& resource_relative_path,
      int resource_id,
      scoped_refptr<net::HttpResponseHeaders> headers,
      mojo::PendingRemote<network::mojom::URLLoaderClient> client) override;
  bool AllowCrossRendererResourceLoad(
      const network::ResourceRequest& request,
      network::mojom::RequestDestination destination,
      ui::PageTransition page_transition,
      int child_id,
      bool is_incognito,
      const Extension* extension,
      const ExtensionSet& extensions,
      const ProcessMap& process_map) override;
  PrefService* GetPrefServiceForContext(
      content::BrowserContext* context) override;
  void GetEarlyExtensionPrefsObservers(
      content::BrowserContext* context,
      std::vector<EarlyExtensionPrefsObserver*>* observers) const override;
  ProcessManagerDelegate* GetProcessManagerDelegate() const override;
  std::unique_ptr<ExtensionHostDelegate> CreateExtensionHostDelegate() override;
  bool DidVersionUpdate(content::BrowserContext* context) override;
  void PermitExternalProtocolHandler() override;
  bool IsInDemoMode() override;
  bool IsScreensaverInDemoMode(const std::string& app_id) override;
  bool IsRunningInForcedAppMode() override;
  bool IsAppModeForcedForApp(const ExtensionId& id) override;
  bool IsLoggedInAsPublicAccount() override;
  ExtensionSystemProvider* GetExtensionSystemFactory() override;
  void RegisterBrowserInterfaceBindersForFrame(
      mojo::BinderMapWithContext<content::RenderFrameHost*>* binder_map,
      content::RenderFrameHost* render_frame_host,
      const Extension* extension) const override;
  std::unique_ptr<RuntimeAPIDelegate> CreateRuntimeAPIDelegate(
      content::BrowserContext* context) const override;
  const ComponentExtensionResourceManager*
  GetComponentExtensionResourceManager() override;
  void BroadcastEventToRenderers(
      events::HistogramValue histogram_value,
      const std::string& event_name,
      std::unique_ptr<base::ListValue> args,
      bool dispatch_to_off_the_record_profiles) override;
  ExtensionCache* GetExtensionCache() override;
  bool IsBackgroundUpdateAllowed() override;
  bool IsMinBrowserVersionSupported(const std::string& min_version) override;
  ExtensionWebContentsObserver* GetExtensionWebContentsObserver(
      content::WebContents* web_contents) override;
  KioskDelegate* GetKioskDelegate() override;
  bool IsLockScreenContext(content::BrowserContext* context) override;
  std::string GetApplicationLocale() override;
  std::string GetUserAgent() const override;

  // Sets the API client.
  void SetAPIClientForTest(ExtensionsAPIClient* api_client);

 private:
  // The single BrowserContext for cast_shell. Not owned.
  content::BrowserContext* browser_context_;

  chromecast::shell::CastNetworkContexts* cast_network_contexts_;

  // The PrefService for |browser_context_|. Not owned.
  PrefService* pref_service_;

  // Support for extension APIs.
  std::unique_ptr<ExtensionsAPIClient> api_client_;

  std::unique_ptr<KioskDelegate> kiosk_delegate_;
};

}  // namespace extensions

#endif  // CHROMECAST_BROWSER_EXTENSIONS_CAST_EXTENSIONS_BROWSER_CLIENT_H_


text:
package com.sksamuel.elastic4s.searches

import com.sksamuel.exts.OptionImplicits._

case class MultiSearchRequest(searches: Iterable[SearchRequest], maxConcurrentSearches: Option[Int] = None) {
  def maxConcurrentSearches(max: Int): MultiSearchRequest = copy(maxConcurrentSearches = max.some)
}


text:
using namespace SiachenGameEngine::Containers;

namespace SiachenGameEngine
{
	namespace GameplayFramework
	{
		RTTI_DEFINITIONS(Attributed)

		Containers::HashMap<std::uint64_t, Containers::Vector<std::string>> Attributed::sPrescribedAttributeCache;

		Attributed::Attributed() : mPrescribedAttributeCount(0)
		{
			AddInternalAttribute("this", static_cast<RTTI*>(this));
			UpdatePrescribedAttributeInfo();
		}

		Attributed::Attributed(const Attributed& rhs) : Scope(rhs)
		{
			(*this)["this"].Set(static_cast<RTTI*>(this));
			SetAuxillaryBegin(rhs.AuxiliaryBegin());
		}

		Attributed& Attributed::operator=(const Attributed& rhs)
		{
			if (this != &rhs)
			{
				Scope::operator=(rhs);

				(*this)["this"].Set(static_cast<RTTI*>(this));
				SetAuxillaryBegin(rhs.AuxiliaryBegin());
			}
			return *this;
		}

		void Attributed::UpdatePrescribedAttributeInfo()
		{

			Vector<std::string> attributeList;
			GetKeys(attributeList);
			std::uint64_t instanceId = TypeIdInstance();

			// Update prescribed attribute count
			mPrescribedAttributeCount = attributeList.Size();

			// Check if the static hashmap has attribute list for this type
			if(!sPrescribedAttributeCache.ContainsKey(instanceId))
			{
				// Insert <classID, Vector of strings> pair into static hashmap
				std::pair<std::uint64_t, Containers::Vector<std::string>> pair(instanceId, Vector<std::string>());
				sPrescribedAttributeCache.Insert(pair);
				CacheHashmapType::Iterator itCache = sPrescribedAttributeCache.Find(instanceId);
				// Fill the prescribed attributes vector if it is empty
				for (std::uint32_t i = 0; i < mPrescribedAttributeCount; ++i)
				{
					std::string attributeName = attributeList.At(i);
					(*itCache).second.PushBack(attributeName);
				}
			}
		}

		void Attributed::SetAuxillaryBegin(std::uint32_t count)
		{
			mPrescribedAttributeCount = count;
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, std::int32_t* const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::IntegerType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, std::float_t* const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::FloatType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, std::string* const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::StringType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, glm::vec4* const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::VectorType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, glm::mat4x4* const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::MatrixType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddExternalAttribute(const std::string& attributeName, RTTI** const externalAttribute, std::uint32_t numberOfValues)
		{
			Datum& datum = Append(attributeName);
			datum.SetType(DatumType::PointerType);
			datum.SetStorage(externalAttribute, numberOfValues);
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, const std::int32_t attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, const std::float_t attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, const std::string& attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, const glm::vec4& attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, const glm::mat4x4& attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, Scope* const attributeValue)
		{
			Datum* scopeDatum = Find(attributeName);
			if (scopeDatum == nullptr)
			{
				Scope& scope = AppendScope(attributeName);
				scope = *attributeValue;
			}
		}

		void Attributed::AddInternalAttribute(const std::string& attributeName, RTTI* const attributeValue)
		{
			Datum& datum = Append(attributeName);
			if (datum.IsEmpty())
			{
				datum.PushBack(attributeValue);
			}
			else
			{
				datum.Set(attributeValue);
			}
		}

		Datum& Attributed::AddInternalAttribute(const std::string& attributeName, DatumType datumType)
		{
			if (datumType == DatumType::UnknownType)
			{
				throw std::runtime_error("Unknown type cannot be inserted into the datum.");
			}
			Datum& datum = Append(attributeName);
			datum.SetType(datumType);
			return datum;
		}

		bool Attributed::IsAttribute(const std::string& attributeName) const
		{
			return (Find(attributeName) != nullptr);
		}

		bool Attributed::IsPrescribedAttribute(const std::string& attributeName) const
		{
			if (IsAttribute(attributeName))
			{
				CacheHashmapType::Iterator it = sPrescribedAttributeCache.Find(TypeIdInstance());

				Vector<std::string>& attributeList = (*it).second;
				if (attributeList.Find(attributeName) != attributeList.end())
				{
					return true;
				}
			}
			return false;
		}

		bool Attributed::IsAuxiliaryAttribute(const std::string& attributeName) const
		{
			if (IsAttribute(attributeName) && !IsPrescribedAttribute(attributeName))
			{
				return true;
			}
			return false;
		}

		Containers::Datum& Attributed::AppendAuxiliaryAttribute(const std::string& attributeName)
		{
			if (IsPrescribedAttribute(attributeName))
			{
				throw std::runtime_error("An prescribed attribute with the same name is already present in the scope.");
			}
			Datum& datum = Append(attributeName);
			return datum;
		}

		std::uint32_t Attributed::AuxiliaryBegin() const
		{
			return mPrescribedAttributeCount;
		}
	}

}


text:
#ifndef SURFACEAPPLET_H
#define SURFACEAPPLET_H

#include "applet.h"

#include "filters/calibrationFilter.h"

#include "widgets/surfaceWidget.h"

#define SURFACE_NAME "surface"
#define SURFACE_TITLE "Surface"

/**
 * Surface applet displays a 3D volume that can be compressed
 */
class SurfaceApplet : public Applet
{

    Q_OBJECT

public:

    static const QString TAG;

    SurfaceApplet(QWidget *parent = 0);

public slots:

    void setFrame( cv::Mat& frame );

private:

    CalibrationFilter *mCalibrationFilter;

    SurfaceWidget *mSurfaceWidget;
};

#endif // SURFACEAPPLET_H


text:
require 'socket'
require 'openssl'

class UriGatherSslCertTask  < BaseTask

  include Task::Web

  def metadata
    { :version => "1.0",
      :name => "uri_gather_ssl_certificate",
      :pretty_name => "URI Gather SSL Certificate",
      :authors => ["jcran"],
      :description => "Grab the SSL certificate from an application server",
      :references => [],
      :allowed_types => ["Uri"],
      :example_entities => [{:type => "Uri", :attributes => {:name => "http://www.intrigue.io"}}],
      :allowed_options => [],
      :created_types => ["DnsRecord","SslCertificate"]
    }
  end

  def run
    super

    uri = _get_entity_attribute "name"
    hostname = URI.parse(uri).host
    port = 443

    begin
      Timeout.timeout(20) do
        # Create a socket and connect
        tcp_client = TCPSocket.new hostname, port
        ssl_client = OpenSSL::SSL::SSLSocket.new tcp_client

        # Grab the cert
        ssl_client.connect

        # Parse the cert
        cert = OpenSSL::X509::Certificate.new(ssl_client.peer_cert)

        # Check the subjectAltName property, and if we have names, here, parse them.
        cert.extensions.each do |ext|
          if ext.oid =~ /subjectAltName/

            alt_names = ext.value.split(",").collect do |x|
              x.gsub(/DNS:/,"").strip
            end

            alt_names.each do |alt_name|
              _create_entity "DnsRecord", { :name => alt_name }
            end

          end
        end

        # Close the sockets
        ssl_client.sysclose
        tcp_client.close

        # Create an SSL Certificate entity
        _create_entity "SslCertificate", {  :name => cert.subject,
                                            :text => cert.to_text }
      end
    rescue Timeout::Error
      @task_log.log "Timed out"
    rescue OpenSSL::SSL::SSLError => e
      @task_log.error "Caught an error: #{e}"
    rescue Errno::ECONNRESET => e
      @task_log.error "Caught an error: #{e}"
    rescue Errno::ECONNREFUSED => e
      @task_log.error "Caught an error: #{e}"
    rescue RuntimeError => e
      @task_log.error "Caught an error: #{e}"
    end

  end

end


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    app:layout_behavior="@string/appbar_scrolling_view_behavior"
    tools:context="info.earthperson.dev.androidproject.MyActivity"
    tools:showIn="@layout/activity_my">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>


text:
package microsoft.exchange.webservices.data.util;

import java.util.HashMap;
import java.util.Map;
import java.util.TimeZone;

/**
 * Miscellany timezone functions
 */
public class TimeZoneUtils {
  //a map of olson name > Microsoft Name
  final static private Map<String, String> olsonTimeZoneToMs = new HashMap<String, String>();

  static {
    olsonTimeZoneToMs.put("Africa/Abidjan", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Accra", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Addis_Ababa", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Algiers", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Asmara", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Asmera", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Bamako", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Bangui", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Banjul", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Bissau", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Blantyre", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Brazzaville", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Bujumbura", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Cairo", "Egypt Standard Time");
    olsonTimeZoneToMs.put("Africa/Casablanca", "Morocco Standard Time");
    olsonTimeZoneToMs.put("Africa/Ceuta", "Romance Standard Time");
    olsonTimeZoneToMs.put("Africa/Conakry", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Dakar", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Dar_es_Salaam", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Djibouti", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Douala", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/El_Aaiun", "Morocco Standard Time");
    olsonTimeZoneToMs.put("Africa/Freetown", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Gaborone", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Harare", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Johannesburg", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Juba", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Kampala", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Khartoum", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Kigali", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Kinshasa", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Lagos", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Libreville", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Lome", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Luanda", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Lubumbashi", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Lusaka", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Malabo", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Maputo", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Maseru", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Mbabane", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Mogadishu", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Monrovia", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Nairobi", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Ndjamena", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Niamey", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Nouakchott", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Ouagadougou", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Porto-Novo", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Sao_Tome", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Timbuktu", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Africa/Tripoli", "Libya Standard Time");
    olsonTimeZoneToMs.put("Africa/Tunis", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Africa/Windhoek", "Namibia Standard Time");
    olsonTimeZoneToMs.put("America/Anchorage", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("America/Anguilla", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Antigua", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Araguaina", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Buenos_Aires", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Catamarca", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/ComodRivadavia", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Cordoba", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Jujuy", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/La_Rioja", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Mendoza", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Rio_Gallegos", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Salta", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/San_Juan", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/San_Luis", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Tucuman", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Argentina/Ushuaia", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Aruba", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Asuncion", "Paraguay Standard Time");
    olsonTimeZoneToMs.put("America/Atikokan", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Bahia", "Bahia Standard Time");
    olsonTimeZoneToMs.put("America/Bahia_Banderas", "Central Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Barbados", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Belem", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Belize", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Blanc-Sablon", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Boa_Vista", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Bogota", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Boise", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Buenos_Aires", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Cambridge_Bay", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Campo_Grande", "Central Brazilian Standard Time");
    olsonTimeZoneToMs.put("America/Cancun", "Eastern Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Caracas", "Venezuela Standard Time");
    olsonTimeZoneToMs.put("America/Catamarca", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Cayenne", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Cayman", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Chicago", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Chihuahua", "Mountain Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Coral_Harbour", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Cordoba", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Costa_Rica", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Creston", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Cuiaba", "Central Brazilian Standard Time");
    olsonTimeZoneToMs.put("America/Curacao", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Danmarkshavn", "UTC");
    olsonTimeZoneToMs.put("America/Dawson", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Dawson_Creek", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Denver", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Detroit", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Dominica", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Edmonton", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Eirunepe", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/El_Salvador", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Ensenada", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Fort_Wayne", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Fortaleza", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Glace_Bay", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("America/Godthab", "Greenland Standard Time");
    olsonTimeZoneToMs.put("America/Goose_Bay", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("America/Grand_Turk", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Grenada", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Guadeloupe", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Guatemala", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Guayaquil", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Guyana", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Halifax", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("America/Havana", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Hermosillo", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Indianapolis", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Knox", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Marengo", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Petersburg", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Tell_City", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Vevay", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Vincennes", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indiana/Winamac", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Indianapolis", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Inuvik", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Iqaluit", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Jamaica", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Jujuy", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Juneau", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("America/Kentucky/Louisville", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Kentucky/Monticello", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Knox_IN", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Kralendijk", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/La_Paz", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Lima", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Los_Angeles", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Louisville", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Lower_Princes", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Maceio", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Managua", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Manaus", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Marigot", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Martinique", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Matamoros", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Mazatlan", "Mountain Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Mendoza", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Menominee", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Merida", "Central Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Mexico_City", "Central Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Moncton", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("America/Monterrey", "Central Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Montevideo", "Montevideo Standard Time");
    olsonTimeZoneToMs.put("America/Montreal", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Montserrat", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Nassau", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/New_York", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Nipigon", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Nome", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("America/Noronha", "UTC-02");
    olsonTimeZoneToMs.put("America/North_Dakota/Beulah", "Central Standard Time");
    olsonTimeZoneToMs.put("America/North_Dakota/Center", "Central Standard Time");
    olsonTimeZoneToMs.put("America/North_Dakota/New_Salem", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Ojinaga", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Panama", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Pangnirtung", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Paramaribo", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Phoenix", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Port-au-Prince", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Port_of_Spain", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Porto_Acre", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Porto_Velho", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Puerto_Rico", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Rainy_River", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Rankin_Inlet", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Recife", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Regina", "Canada Central Standard Time");
    olsonTimeZoneToMs.put("America/Resolute", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Rio_Branco", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Rosario", "Argentina Standard Time");
    olsonTimeZoneToMs.put("America/Santa_Isabel", "Pacific Standard Time (Mexico)");
    olsonTimeZoneToMs.put("America/Santarem", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Santiago", "Pacific SA Standard Time");
    olsonTimeZoneToMs.put("America/Santo_Domingo", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Sao_Paulo", "E. South America Standard Time");
    olsonTimeZoneToMs.put("America/Scoresbysund", "Azores Standard Time");
    olsonTimeZoneToMs.put("America/Shiprock", "Mountain Standard Time");
    olsonTimeZoneToMs.put("America/Sitka", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("America/St_Barthelemy", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/St_Johns", "Newfoundland Standard Time");
    olsonTimeZoneToMs.put("America/St_Kitts", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/St_Lucia", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/St_Thomas", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/St_Vincent", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Swift_Current", "Canada Central Standard Time");
    olsonTimeZoneToMs.put("America/Tegucigalpa", "Central America Standard Time");
    olsonTimeZoneToMs.put("America/Thule", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("America/Thunder_Bay", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Tijuana", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Toronto", "Eastern Standard Time");
    olsonTimeZoneToMs.put("America/Tortola", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Vancouver", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Virgin", "SA Western Standard Time");
    olsonTimeZoneToMs.put("America/Whitehorse", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Winnipeg", "Central Standard Time");
    olsonTimeZoneToMs.put("America/Yakutat", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("America/Yellowknife", "Mountain Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Casey", "W. Australia Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Davis", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Antarctica/DumontDUrville", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Macquarie", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Mawson", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Antarctica/McMurdo", "New Zealand Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Palmer", "Pacific SA Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Rothera", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("Antarctica/South_Pole", "New Zealand Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Syowa", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Antarctica/Vostok", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Arctic/Longyearbyen", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Asia/Aden", "Arab Standard Time");
    olsonTimeZoneToMs.put("Asia/Almaty", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Amman", "Jordan Standard Time");
    olsonTimeZoneToMs.put("Asia/Anadyr", "Russia Time Zone 11");
    olsonTimeZoneToMs.put("Asia/Aqtau", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Aqtobe", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Ashgabat", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Ashkhabad", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Baghdad", "Arabic Standard Time");
    olsonTimeZoneToMs.put("Asia/Bahrain", "Arab Standard Time");
    olsonTimeZoneToMs.put("Asia/Baku", "Azerbaijan Standard Time");
    olsonTimeZoneToMs.put("Asia/Bangkok", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Beirut", "Middle East Standard Time");
    olsonTimeZoneToMs.put("Asia/Bishkek", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Brunei", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Calcutta", "India Standard Time");
    olsonTimeZoneToMs.put("Asia/Chita", "North Asia East Standard Time");
    olsonTimeZoneToMs.put("Asia/Choibalsan", "Ulaanbaatar Standard Time");
    olsonTimeZoneToMs.put("Asia/Chongqing", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Chungking", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Colombo", "Sri Lanka Standard Time");
    olsonTimeZoneToMs.put("Asia/Dacca", "Bangladesh Standard Time");
    olsonTimeZoneToMs.put("Asia/Damascus", "Syria Standard Time");
    olsonTimeZoneToMs.put("Asia/Dhaka", "Bangladesh Standard Time");
    olsonTimeZoneToMs.put("Asia/Dili", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Asia/Dubai", "Arabian Standard Time");
    olsonTimeZoneToMs.put("Asia/Dushanbe", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Harbin", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Ho_Chi_Minh", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Hong_Kong", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Hovd", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Irkutsk", "North Asia East Standard Time");
    olsonTimeZoneToMs.put("Asia/Istanbul", "Turkey Standard Time");
    olsonTimeZoneToMs.put("Asia/Jakarta", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Jayapura", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Asia/Jerusalem", "Israel Standard Time");
    olsonTimeZoneToMs.put("Asia/Kabul", "Afghanistan Standard Time");
    olsonTimeZoneToMs.put("Asia/Kamchatka", "Russia Time Zone 11");
    olsonTimeZoneToMs.put("Asia/Karachi", "Pakistan Standard Time");
    olsonTimeZoneToMs.put("Asia/Kashgar", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Kathmandu", "Nepal Standard Time");
    olsonTimeZoneToMs.put("Asia/Katmandu", "Nepal Standard Time");
    olsonTimeZoneToMs.put("Asia/Khandyga", "Yakutsk Standard Time");
    olsonTimeZoneToMs.put("Asia/Kolkata", "India Standard Time");
    olsonTimeZoneToMs.put("Asia/Krasnoyarsk", "North Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Kuala_Lumpur", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Kuching", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Kuwait", "Arab Standard Time");
    olsonTimeZoneToMs.put("Asia/Macao", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Macau", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Magadan", "Magadan Standard Time");
    olsonTimeZoneToMs.put("Asia/Makassar", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Manila", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Muscat", "Arabian Standard Time");
    olsonTimeZoneToMs.put("Asia/Nicosia", "GTB Standard Time");
    olsonTimeZoneToMs.put("Asia/Novokuznetsk", "North Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Novosibirsk", "N. Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Omsk", "N. Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Oral", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Phnom_Penh", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Pontianak", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Pyongyang", "Korea Standard Time");
    olsonTimeZoneToMs.put("Asia/Qatar", "Arab Standard Time");
    olsonTimeZoneToMs.put("Asia/Qyzylorda", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Rangoon", "Myanmar Standard Time");
    olsonTimeZoneToMs.put("Asia/Riyadh", "Arab Standard Time");
    olsonTimeZoneToMs.put("Asia/Saigon", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Sakhalin", "Vladivostok Standard Time");
    olsonTimeZoneToMs.put("Asia/Samarkand", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Seoul", "Korea Standard Time");
    olsonTimeZoneToMs.put("Asia/Shanghai", "China Standard Time");
    olsonTimeZoneToMs.put("Asia/Singapore", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Srednekolymsk", "Russia Time Zone 10");
    olsonTimeZoneToMs.put("Asia/Taipei", "Taipei Standard Time");
    olsonTimeZoneToMs.put("Asia/Tashkent", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Tbilisi", "Georgian Standard Time");
    olsonTimeZoneToMs.put("Asia/Tehran", "Iran Standard Time");
    olsonTimeZoneToMs.put("Asia/Tel_Aviv", "Israel Standard Time");
    olsonTimeZoneToMs.put("Asia/Thimbu", "Bangladesh Standard Time");
    olsonTimeZoneToMs.put("Asia/Thimphu", "Bangladesh Standard Time");
    olsonTimeZoneToMs.put("Asia/Tokyo", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Asia/Ujung_Pandang", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Asia/Ulaanbaatar", "Ulaanbaatar Standard Time");
    olsonTimeZoneToMs.put("Asia/Ulan_Bator", "Ulaanbaatar Standard Time");
    olsonTimeZoneToMs.put("Asia/Urumqi", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Ust-Nera", "Vladivostok Standard Time");
    olsonTimeZoneToMs.put("Asia/Vientiane", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Asia/Vladivostok", "Vladivostok Standard Time");
    olsonTimeZoneToMs.put("Asia/Yakutsk", "Yakutsk Standard Time");
    olsonTimeZoneToMs.put("Asia/Yekaterinburg", "Ekaterinburg Standard Time");
    olsonTimeZoneToMs.put("Asia/Yerevan", "Caucasus Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Azores", "Azores Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Bermuda", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Canary", "GMT Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Cape_Verde", "Cape Verde Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Faeroe", "GMT Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Faroe", "GMT Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Jan_Mayen", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Madeira", "GMT Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Reykjavik", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Atlantic/South_Georgia", "UTC-02");
    olsonTimeZoneToMs.put("Atlantic/St_Helena", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Atlantic/Stanley", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/ACT", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/Adelaide", "Cen. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Brisbane", "E. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Broken_Hill", "Cen. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Canberra", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/Currie", "Tasmania Standard Time");
    olsonTimeZoneToMs.put("Australia/Darwin", "AUS Central Standard Time");
    olsonTimeZoneToMs.put("Australia/Hobart", "Tasmania Standard Time");
    olsonTimeZoneToMs.put("Australia/Lindeman", "E. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Melbourne", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/NSW", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/North", "AUS Central Standard Time");
    olsonTimeZoneToMs.put("Australia/Perth", "W. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Queensland", "E. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/South", "Cen. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Sydney", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/Tasmania", "Tasmania Standard Time");
    olsonTimeZoneToMs.put("Australia/Victoria", "AUS Eastern Standard Time");
    olsonTimeZoneToMs.put("Australia/West", "W. Australia Standard Time");
    olsonTimeZoneToMs.put("Australia/Yancowinna", "Cen. Australia Standard Time");
    olsonTimeZoneToMs.put("Brazil/Acre", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("Brazil/DeNoronha", "UTC-02");
    olsonTimeZoneToMs.put("Brazil/East", "E. South America Standard Time");
    olsonTimeZoneToMs.put("Brazil/West", "SA Western Standard Time");
    olsonTimeZoneToMs.put("CST6CDT", "Central Standard Time");
    olsonTimeZoneToMs.put("Canada/Atlantic", "Atlantic Standard Time");
    olsonTimeZoneToMs.put("Canada/Central", "Central Standard Time");
    olsonTimeZoneToMs.put("Canada/East-Saskatchewan", "Canada Central Standard Time");
    olsonTimeZoneToMs.put("Canada/Eastern", "Eastern Standard Time");
    olsonTimeZoneToMs.put("Canada/Mountain", "Mountain Standard Time");
    olsonTimeZoneToMs.put("Canada/Newfoundland", "Newfoundland Standard Time");
    olsonTimeZoneToMs.put("Canada/Pacific", "Pacific Standard Time");
    olsonTimeZoneToMs.put("Canada/Saskatchewan", "Canada Central Standard Time");
    olsonTimeZoneToMs.put("Canada/Yukon", "Pacific Standard Time");
    olsonTimeZoneToMs.put("Chile/Continental", "Pacific SA Standard Time");
    olsonTimeZoneToMs.put("Cuba", "Eastern Standard Time");
    olsonTimeZoneToMs.put("EST", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("EST5EDT", "Eastern Standard Time");
    olsonTimeZoneToMs.put("Egypt", "Egypt Standard Time");
    olsonTimeZoneToMs.put("Eire", "GMT Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT", "UTC");
    olsonTimeZoneToMs.put("Etc/GMT+0", "UTC");
    olsonTimeZoneToMs.put("Etc/GMT+1", "Cape Verde Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+10", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+11", "UTC-11");
    olsonTimeZoneToMs.put("Etc/GMT+12", "Dateline Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+2", "UTC-02");
    olsonTimeZoneToMs.put("Etc/GMT+3", "SA Eastern Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+4", "SA Western Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+5", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+6", "Central America Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT+7", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-0", "UTC");
    olsonTimeZoneToMs.put("Etc/GMT-1", "W. Central Africa Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-10", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-11", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-12", "UTC+12");
    olsonTimeZoneToMs.put("Etc/GMT-13", "Tonga Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-14", "Line Islands Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-2", "South Africa Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-3", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-4", "Arabian Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-5", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-6", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-7", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-8", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT-9", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Etc/GMT0", "UTC");
    olsonTimeZoneToMs.put("Etc/Greenwich", "UTC");
    olsonTimeZoneToMs.put("Etc/UCT", "UTC");
    olsonTimeZoneToMs.put("Etc/UTC", "UTC");
    olsonTimeZoneToMs.put("Etc/Universal", "UTC");
    olsonTimeZoneToMs.put("Etc/Zulu", "UTC");
    olsonTimeZoneToMs.put("Europe/Amsterdam", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Andorra", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Athens", "GTB Standard Time");
    olsonTimeZoneToMs.put("Europe/Belfast", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Belgrade", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Berlin", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Bratislava", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Brussels", "Romance Standard Time");
    olsonTimeZoneToMs.put("Europe/Bucharest", "GTB Standard Time");
    olsonTimeZoneToMs.put("Europe/Budapest", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Busingen", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Chisinau", "GTB Standard Time");
    olsonTimeZoneToMs.put("Europe/Copenhagen", "Romance Standard Time");
    olsonTimeZoneToMs.put("Europe/Dublin", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Gibraltar", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Guernsey", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Helsinki", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Isle_of_Man", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Istanbul", "Turkey Standard Time");
    olsonTimeZoneToMs.put("Europe/Jersey", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Kaliningrad", "Kaliningrad Standard Time");
    olsonTimeZoneToMs.put("Europe/Kiev", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Lisbon", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Ljubljana", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/London", "GMT Standard Time");
    olsonTimeZoneToMs.put("Europe/Luxembourg", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Madrid", "Romance Standard Time");
    olsonTimeZoneToMs.put("Europe/Malta", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Mariehamn", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Minsk", "Belarus Standard Time");
    olsonTimeZoneToMs.put("Europe/Monaco", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Moscow", "Russian Standard Time");
    olsonTimeZoneToMs.put("Europe/Nicosia", "GTB Standard Time");
    olsonTimeZoneToMs.put("Europe/Oslo", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Paris", "Romance Standard Time");
    olsonTimeZoneToMs.put("Europe/Podgorica", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Prague", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Riga", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Rome", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Samara", "Russia Time Zone 3");
    olsonTimeZoneToMs.put("Europe/San_Marino", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Sarajevo", "Central European Standard Time");
    olsonTimeZoneToMs.put("Europe/Simferopol", "Russian Standard Time");
    olsonTimeZoneToMs.put("Europe/Skopje", "Central European Standard Time");
    olsonTimeZoneToMs.put("Europe/Sofia", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Stockholm", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Tallinn", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Tirane", "Central Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Tiraspol", "GTB Standard Time");
    olsonTimeZoneToMs.put("Europe/Uzhgorod", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Vaduz", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Vatican", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Vienna", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("Europe/Vilnius", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Volgograd", "Russian Standard Time");
    olsonTimeZoneToMs.put("Europe/Warsaw", "Central European Standard Time");
    olsonTimeZoneToMs.put("Europe/Zagreb", "Central European Standard Time");
    olsonTimeZoneToMs.put("Europe/Zaporozhye", "FLE Standard Time");
    olsonTimeZoneToMs.put("Europe/Zurich", "W. Europe Standard Time");
    olsonTimeZoneToMs.put("GB", "GMT Standard Time");
    olsonTimeZoneToMs.put("GB-Eire", "GMT Standard Time");
    olsonTimeZoneToMs.put("GMT", "UTC");
    olsonTimeZoneToMs.put("GMT+0", "UTC");
    olsonTimeZoneToMs.put("GMT-0", "UTC");
    olsonTimeZoneToMs.put("GMT0", "UTC");
    olsonTimeZoneToMs.put("Greenwich", "UTC");
    olsonTimeZoneToMs.put("HST", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Hongkong", "China Standard Time");
    olsonTimeZoneToMs.put("Iceland", "Greenwich Standard Time");
    olsonTimeZoneToMs.put("Indian/Antananarivo", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Indian/Chagos", "Central Asia Standard Time");
    olsonTimeZoneToMs.put("Indian/Christmas", "SE Asia Standard Time");
    olsonTimeZoneToMs.put("Indian/Cocos", "Myanmar Standard Time");
    olsonTimeZoneToMs.put("Indian/Comoro", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Indian/Kerguelen", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Indian/Mahe", "Mauritius Standard Time");
    olsonTimeZoneToMs.put("Indian/Maldives", "West Asia Standard Time");
    olsonTimeZoneToMs.put("Indian/Mauritius", "Mauritius Standard Time");
    olsonTimeZoneToMs.put("Indian/Mayotte", "E. Africa Standard Time");
    olsonTimeZoneToMs.put("Indian/Reunion", "Mauritius Standard Time");
    olsonTimeZoneToMs.put("Iran", "Iran Standard Time");
    olsonTimeZoneToMs.put("Israel", "Israel Standard Time");
    olsonTimeZoneToMs.put("Jamaica", "SA Pacific Standard Time");
    olsonTimeZoneToMs.put("Japan", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Kwajalein", "UTC+12");
    olsonTimeZoneToMs.put("Libya", "Libya Standard Time");
    olsonTimeZoneToMs.put("MST", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("MST7MDT", "Mountain Standard Time");
    olsonTimeZoneToMs.put("Mexico/BajaNorte", "Pacific Standard Time");
    olsonTimeZoneToMs.put("Mexico/BajaSur", "Mountain Standard Time (Mexico)");
    olsonTimeZoneToMs.put("Mexico/General", "Central Standard Time (Mexico)");
    olsonTimeZoneToMs.put("NZ", "New Zealand Standard Time");
    olsonTimeZoneToMs.put("Navajo", "Mountain Standard Time");
    olsonTimeZoneToMs.put("PRC", "China Standard Time");
    olsonTimeZoneToMs.put("PST8PDT", "Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Apia", "Samoa Standard Time");
    olsonTimeZoneToMs.put("Pacific/Auckland", "New Zealand Standard Time");
    olsonTimeZoneToMs.put("Pacific/Bougainville", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Chuuk", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Efate", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Enderbury", "Tonga Standard Time");
    olsonTimeZoneToMs.put("Pacific/Fakaofo", "Tonga Standard Time");
    olsonTimeZoneToMs.put("Pacific/Fiji", "Fiji Standard Time");
    olsonTimeZoneToMs.put("Pacific/Funafuti", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Galapagos", "Central America Standard Time");
    olsonTimeZoneToMs.put("Pacific/Guadalcanal", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Guam", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Honolulu", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Pacific/Johnston", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Pacific/Kiritimati", "Line Islands Standard Time");
    olsonTimeZoneToMs.put("Pacific/Kosrae", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Kwajalein", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Majuro", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Midway", "UTC-11");
    olsonTimeZoneToMs.put("Pacific/Nauru", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Niue", "UTC-11");
    olsonTimeZoneToMs.put("Pacific/Noumea", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Pago_Pago", "UTC-11");
    olsonTimeZoneToMs.put("Pacific/Palau", "Tokyo Standard Time");
    olsonTimeZoneToMs.put("Pacific/Pohnpei", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Ponape", "Central Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Port_Moresby", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Rarotonga", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Pacific/Saipan", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Samoa", "UTC-11");
    olsonTimeZoneToMs.put("Pacific/Tahiti", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("Pacific/Tarawa", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Tongatapu", "Tonga Standard Time");
    olsonTimeZoneToMs.put("Pacific/Truk", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Pacific/Wake", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Wallis", "UTC+12");
    olsonTimeZoneToMs.put("Pacific/Yap", "West Pacific Standard Time");
    olsonTimeZoneToMs.put("Poland", "Central European Standard Time");
    olsonTimeZoneToMs.put("Portugal", "GMT Standard Time");
    olsonTimeZoneToMs.put("ROC", "Taipei Standard Time");
    olsonTimeZoneToMs.put("ROK", "Korea Standard Time");
    olsonTimeZoneToMs.put("Singapore", "Singapore Standard Time");
    olsonTimeZoneToMs.put("Turkey", "Turkey Standard Time");
    olsonTimeZoneToMs.put("UCT", "UTC");
    olsonTimeZoneToMs.put("US/Alaska", "Alaskan Standard Time");
    olsonTimeZoneToMs.put("US/Arizona", "US Mountain Standard Time");
    olsonTimeZoneToMs.put("US/Central", "Central Standard Time");
    olsonTimeZoneToMs.put("US/East-Indiana", "US Eastern Standard Time");
    olsonTimeZoneToMs.put("US/Eastern", "Eastern Standard Time");
    olsonTimeZoneToMs.put("US/Hawaii", "Hawaiian Standard Time");
    olsonTimeZoneToMs.put("US/Indiana-Starke", "Central Standard Time");
    olsonTimeZoneToMs.put("US/Michigan", "Eastern Standard Time");
    olsonTimeZoneToMs.put("US/Mountain", "Mountain Standard Time");
    olsonTimeZoneToMs.put("US/Pacific", "Pacific Standard Time");
    olsonTimeZoneToMs.put("US/Pacific-New", "Pacific Standard Time");
    olsonTimeZoneToMs.put("US/Samoa", "UTC-11");
    olsonTimeZoneToMs.put("UTC", "UTC");
    olsonTimeZoneToMs.put("Universal", "UTC");
    olsonTimeZoneToMs.put("W-SU", "Russian Standard Time");
    olsonTimeZoneToMs.put("Zulu", "UTC");
    //additions outside of Unicode list
    olsonTimeZoneToMs.put("America/Adak", "Hawaiian Standard Time,(UTC-10:00) Hawaii");
    olsonTimeZoneToMs.put("America/Atka", "Hawaiian Standard Time,(UTC-10:00) Hawaii");
    olsonTimeZoneToMs.put("America/Metlakatla", "Pacific Standard Time");
    olsonTimeZoneToMs.put("America/Miquelon", "South America Standard Time");
    olsonTimeZoneToMs.put("Asia/Gaza", "Middle East Standard Time");
  }

  /**
   * Convert Olson TimeZone to Microsoft TimeZone Generated using Unicode CLDR project Example:
   * https://gist.github.com/scottmac/655675e9b4d4913c539c
   *
   * @param timeZone java timezone (Olson)
   * @return a microsoft timezone identifier (ala Eastern Standard Time)
   */
  public static String getMicrosoftTimeZoneName(TimeZone timeZone) {
    return olsonTimeZoneToMs.get(timeZone.getID());
  }

}


text:
using System;
using System.Collections.Generic;
using Collectively.Services.Remarks.Domain;
using Collectively.Services.Remarks.Tests.EndToEnd.Framework;
using System.Linq;
using Machine.Specifications;

namespace Collectively.Services.Remarks.Tests.EndToEnd.Specs
{
    public abstract class RemarkModule_specs
    {
        protected static IHttpClient HttpClient = new CustomHttpClient("http://localhost:10002");
        protected static Remark Remark;
        protected static IEnumerable<Remark> Remarks;
        protected static IEnumerable<Category> Categories;
        protected static Guid RemarkId;

        protected static void InitializeAndFetch()
        {
            var remark = FetchRemarks().First();
            RemarkId = remark.Id;
        }

        protected static IEnumerable<Remark> FetchRemarks(int page = 1, int results = 1000)
            => HttpClient.GetAsync<IEnumerable<Remark>>($"remarks?results={results}&page={page}").WaitForResult();

        protected static IEnumerable<Category> FetchCategories()
            => HttpClient.GetAsync<IEnumerable<Category>>("remarks/categories").WaitForResult();

        protected static Remark FetchRemark(Guid id)
            => HttpClient.GetAsync<Remark>($"remarks/{id}").WaitForResult();
    }

    [Subject("RemarkService fetch remarks")]
    public class when_fetching_remarks : RemarkModule_specs
    {
        protected static int Results = 25;

        Because of = () => Remarks = FetchRemarks(results: Results);

        It should_not_be_null = () => Remarks.ShouldNotBeNull();

        It should_not_be_empty = () => Remarks.ShouldNotBeEmpty();

        It should_return_not_more_than_requested_amount_of_data = ()
            => Remarks.Count().ShouldBeLessThanOrEqualTo(Results);
    }

    [Subject("RemarkService fetch single remark")]
    public class when_fetching_single_remark : RemarkModule_specs
    {
        Establish context = () => InitializeAndFetch();

        Because of = () => Remark = FetchRemark(RemarkId);

        It should_not_be_null = () => Remark.ShouldNotBeNull();

        It should_have_correct_id = () => Remark.Id.ShouldEqual(RemarkId);

        It should_return_remark = () =>
        {
            Remark.Id.ShouldNotEqual(Guid.Empty);
            Remark.Author.ShouldNotBeNull();
            Remark.Category.ShouldNotBeNull();
            Remark.CreatedAt.ShouldNotEqual(default(DateTime));
            Remark.Location.ShouldNotBeNull();
        };
    }

    [Subject("RemarkService fetch categories")]
    public class when_fetching_categories : RemarkModule_specs
    {
        Because of = () => Categories = FetchCategories();

        It should_not_be_null = () => Categories.ShouldNotBeNull();

        It should_not_be_empty = () => Categories.ShouldNotBeEmpty();
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.amir.dhp">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name"
            android:theme="@style/AppTheme.NoActionBar"
            android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <activity android:name=".FocoMainActivity" android:screenOrientation="portrait"/>
        <activity android:name=".FocoMenuActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>
        <activity android:name=".FocoMealActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>

        <activity android:name=".CollisMainActivity" android:screenOrientation="portrait"/>
        <activity android:name=".CollisMenuActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>
        <activity android:name=".CollisMealActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>

        <activity android:name=".HopMainActivity" android:screenOrientation="portrait"/>
        <activity android:name=".HopMenuActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>
        <activity android:name=".HopMealActivity" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan"/>

        <activity android:name=".MenuItemDisplayActivity" android:screenOrientation="portrait"/>

        <activity android:name=".CrowdedActivity" android:screenOrientation="portrait"/>
    </application>

</manifest>


text:
<?php

namespace change;

class Backlog
{

}