text:
package com.morgan.design.activity.fragment;

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.ExpandableListView;

import com.morgan.design.R;
import com.morgan.design.TeaApplication;
import com.morgan.design.activity.TeaRoundHomeActivity;
import com.morgan.design.adaptor.refactor.BrewGroupsExpandableListAdapter;
import com.morgan.design.adaptor.refactor.BrewGroupsExpandableListAdapter.OnRemovePlayerFromGroup;
import com.morgan.design.db.domain.BrewGroup;
import com.morgan.design.db.domain.BrewPlayer;
import com.morgan.design.utils.InputUtils;

import java.util.List;

public class BrewGroupsFragment extends BaseBrewFragment implements OnRemovePlayerFromGroup {

    private BrewGroupsExpandableListAdapter adapter;
    private List<BrewGroup> brewGroups;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        brewGroups = getBrewRepository().findAllBrewGroups();
    }

    @Override
    public void onResume() {
        super.onResume();
        loadGroups();
    }

    @Override
    public void onTrashClicked(BrewPlayer player, int groupPosition, int childPosition) {

        BrewGroup group = brewGroups.get(groupPosition);

        group.getBrewPlayers().remove(player);

        getBrewRepository().updateGroup(group);

        getBrewRepository().deletePlayer(player);

        getBrewRepository().removePlayerStats(player);

        if (group.hasNoPlayers()) {
            getBrewRepository().deleteGroup(group);
        }
        loadGroups();
    }

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

        final ExpandableListView listView = (ExpandableListView) rootView.findViewById(R.id.brew_groups_expandable_list_view);

        adapter = new BrewGroupsExpandableListAdapter(brewGroups, getActivity(), this);

        listView.setAdapter(adapter);

        listView.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
            @Override
            public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
                int itemType = ExpandableListView.getPackedPositionType(id);

                if (itemType == ExpandableListView.PACKED_POSITION_TYPE_CHILD) {
                    // int childPosition = ExpandableListView.getPackedPositionChild(id);
                    // int groupPosition = ExpandableListView.getPackedPositionGroup(id);
                    return false; // true if we consumed the click, false if not
                } else if (itemType == ExpandableListView.PACKED_POSITION_TYPE_GROUP) {
                    launchManagegroupDialog(ExpandableListView.getPackedPositionGroup(id));
                    return true; // true if we consumed the click, false if not

                }
                // null item; we don't consume the click
                return false;
            }
        });

        return rootView;
    }

    protected void launchManagegroupDialog(int groupPosition) {

        final BrewGroup group = brewGroups.get(groupPosition);

        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()).setCancelable(true);
        builder.setTitle("Manage Group: " + group.getName());
        builder.setMessage(" >> Load Brew Group\n" + " >> Rename Group\n" + " >> Delete Group");
        builder.setNegativeButton("Load", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface dialog, final int id) {
                loadBrewGroup(group);
            }
        }).setNeutralButton("Rename", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface dialog, final int id) {
                renameBrewGroup(group);
            }
        }).setPositiveButton("Delete", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface dialog, final int id) {
                deleteBrewGroup(group);
            }
        }).create().show();

    }

    protected void deleteBrewGroup(BrewGroup group) {
        for (final BrewPlayer player : group.getBrewPlayers()) {
            getBrewRepository().removePlayerStats(player);
        }
        getBrewRepository().deleteGroup(group);
        loadGroups();
    }

    protected void renameBrewGroup(final BrewGroup group) {

        final LayoutInflater factory = LayoutInflater.from(getActivity());

        final View textEntryView = factory.inflate(R.layout.add_group_dialog, null);
        final AlertDialog dialog = new AlertDialog.Builder(getActivity()).setTitle("Edit Group Name").setIcon(R.drawable.add_group)
                .setView(textEntryView).create();

        final EditText addGroupEditText = (EditText) textEntryView.findViewById(R.id.add_group_edit_text);
        addGroupEditText.setText(group.getName());
        addGroupEditText.setFocusable(true);
        addGroupEditText.requestFocus();

        InputUtils.showKeyBoard(addGroupEditText, getActivity());

        dialog.setButton(Dialog.BUTTON_POSITIVE, getString(R.string.edit), new DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface dialog, final int whichButton) {
                final String groupName = addGroupEditText.getEditableText().toString();
                InputUtils.hideKeyBoard(addGroupEditText, getActivity());
                addGroupEditText.clearFocus();
                group.setName(groupName);
                getBrewRepository().updateGroup(group);
                shortToast("Updated Group: " + group.getName());
                loadGroups();
            }
        });
        dialog.setButton(Dialog.BUTTON_NEGATIVE, getString(R.string.cancel), new DialogInterface.OnClickListener() {
            @Override
            public void onClick(final DialogInterface dialog, final int whichButton) {
                InputUtils.hideKeyBoard(addGroupEditText, getActivity());
                addGroupEditText.clearFocus();
                dialog.cancel();
            }
        });
        dialog.show();
    }

    protected void loadBrewGroup(BrewGroup group) {
        final Intent intent = new Intent(getActivity(), TeaRoundHomeActivity.class);
        intent.putExtra(TeaApplication.GROUP_ID, group.getId());
        startActivity(intent);
    }

    private void loadGroups() {
        brewGroups = getBrewRepository().findAllBrewGroups();
        adapter.setBrewGroups(brewGroups);
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ClearCaseSharedConfig">
    <option name="myUseUcmModel" value="true" />
  </component>
  <component name="VcsDirectoryMappings">
    <mapping directory="" vcs="svn" />
    <mapping directory="$PROJECT_DIR$/../../.." vcs="svn" />
  </component>
</project>

redpajama_set_name: RedPajamaGithub


text:
.class public abstract Landroid/content/pm/permission/RuntimePermissionPresenter$OnResultCallback;
.super Ljava/lang/Object;
.source "RuntimePermissionPresenter.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Landroid/content/pm/permission/RuntimePermissionPresenter;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x409
    name = "OnResultCallback"
.end annotation

# direct methods
.method public constructor <init>()V
    .locals 0

    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method

# virtual methods
.method public onGetAppPermissions(Ljava/util/List;)V
    .locals 0
    .annotation system Ldalvik/annotation/Signature;
        value = {
            "(",
            "Ljava/util/List",
            "<",
            "Landroid/content/pm/permission/RuntimePermissionPresentationInfo;",
            ">;)V"
        }
    .end annotation

    return-void
.end method


text:
<?php declare(strict_types=1);

namespace PHPUnit\Metadata;

/**
 * @internal This class is not covered by the backward compatibility promise for PHPUnit
 * @psalm-immutable
 */
final class BeforeClass extends Metadata
{
    public function isBeforeClass(): bool
    {
        return true;
    }
}


text:
package org.apache.hadoop.security;

import org.apache.hadoop.conf.Configuration;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import javax.naming.CommunicationException;
import javax.naming.directory.SearchControls;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.atomic.AtomicInteger;

import static org.apache.hadoop.security.LdapGroupsMapping.LDAP_NUM_ATTEMPTS_BEFORE_FAILOVER_KEY;
import static org.apache.hadoop.security.LdapGroupsMapping.LDAP_NUM_ATTEMPTS_KEY;
import static org.apache.hadoop.security.LdapGroupsMapping.LDAP_URL_KEY;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

/**
 * Test failover functionality for switching to different
 * LDAP server URLs upon failures.
 */
public class TestLdapGroupsMappingWithFailover
    extends TestLdapGroupsMappingBase {

  private static final String TEST_USER_NAME = "some_user";

  /**
   * Test that when disabled, we will retry the configured number
   * of times using the same LDAP server.
   */
  @Test
  public void testDoesNotFailoverWhenDisabled() throws Exception {
    final int numAttempts = 3;
    Configuration conf = getBaseConf();
    conf.setStrings(LDAP_URL_KEY, "ldap://test", "ldap://test1",
        "ldap://test2");
    DummyLdapCtxFactory.setExpectedLdapUrl("ldap://test");
    conf.setInt(LDAP_NUM_ATTEMPTS_KEY, numAttempts);
    conf.setInt(LDAP_NUM_ATTEMPTS_BEFORE_FAILOVER_KEY, numAttempts);

    when(getContext().search(anyString(), anyString(), any(Object[].class),
        any(SearchControls.class))).thenThrow(new CommunicationException());

    LdapGroupsMapping groupsMapping = getGroupsMapping();
    groupsMapping.setConf(conf);

    List<String> groups = groupsMapping.getGroups(TEST_USER_NAME);
    assertTrue(groups.isEmpty());

    // Test that we made 3 attempts using the same server
    verify(getContext(), times(numAttempts)).search(anyString(), anyString(),
        any(Object[].class), any(SearchControls.class));
  }

  /**
   * Test that when configured, we will make the specified amount of
   * attempts using one ldap url before failing over to the next one.
   *
   * This also tests that we wrap back to the first server
   * if we've tried them all.
   */
  @Test
  public void testFailover() throws Exception {
    Queue<String> ldapUrls = new LinkedList<>();
    ldapUrls.add("ldap://test");
    ldapUrls.add("ldap://test1");
    ldapUrls.add("ldap://test2");

    final int numAttempts = 12;
    final int numAttemptsBeforeFailover = 2;

    Configuration conf = getBaseConf();
    conf.setStrings(LDAP_URL_KEY, "ldap://test", "ldap://test1",
        "ldap://test2");
    conf.setInt(LDAP_NUM_ATTEMPTS_KEY, numAttempts);
    conf.setInt(LDAP_NUM_ATTEMPTS_BEFORE_FAILOVER_KEY,
        numAttemptsBeforeFailover);

    // Set the first expected url and add it back to the queue
    String nextLdapUrl = ldapUrls.remove();
    DummyLdapCtxFactory.setExpectedLdapUrl(nextLdapUrl);
    ldapUrls.add(nextLdapUrl);

    // Number of attempts using a single ldap server url
    final AtomicInteger serverAttempts = new AtomicInteger(
        numAttemptsBeforeFailover);

    when(getContext().search(anyString(), anyString(), any(Object[].class),
        any(SearchControls.class))).thenAnswer(new Answer<Object>() {
          @Override
          public Object answer(InvocationOnMock invocationOnMock)
              throws Throwable {
            if (serverAttempts.get() == 1) {
              // Take the head of the queue and re-queue it to the back
              String nextLdapUrl = ldapUrls.remove();
              ldapUrls.add(nextLdapUrl);

              DummyLdapCtxFactory.setExpectedLdapUrl(nextLdapUrl);
              serverAttempts.set(numAttemptsBeforeFailover);
            } else {
              serverAttempts.decrementAndGet();
            }
            throw new CommunicationException();
          }
        });

    LdapGroupsMapping groupsMapping = getGroupsMapping();
    groupsMapping.setConf(conf);

    List<String> groups = groupsMapping.getGroups(TEST_USER_NAME);
    assertTrue(groups.isEmpty());

    // Test that we made 6 attempts overall
    verify(getContext(), times(numAttempts)).search(anyString(),
        anyString(), any(Object[].class), any(SearchControls.class));
  }
}


text:
\section{Like\-Op Struct Reference}
\label{structLikeOp}\index{LikeOp@{LikeOp}}
\subsection*{Data Fields}
\begin{CompactItemize}
\item
\bf{Token} \bf{e\-Operator}
\item
int \bf{not}
\end{CompactItemize}

\subsection{Field Documentation}
\index{LikeOp@{Like\-Op}!eOperator@{eOperator}}
\index{eOperator@{eOperator}!LikeOp@{Like\-Op}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\bf{Token} \bf{Like\-Op::e\-Operator}}\label{structLikeOp_f571bdc1eb91919900869662af6f666a}

\index{LikeOp@{Like\-Op}!not@{not}}
\index{not@{not}!LikeOp@{Like\-Op}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int \bf{Like\-Op::not}}\label{structLikeOp_09bf2a433f63ef8fa86ab73f7b6eefd7}

The documentation for this struct was generated from the following files:\begin{CompactItemize}
\item
deps/sqlite/\bf{sqlite3.c}\item
deps/sqlite-3.7.3/\bf{sqlite3.c}\end{CompactItemize}


text:
#region License

#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
using Gremlin.Net.Driver;
using Gremlin.Net.Driver.Exceptions;
using Gremlin.Net.Driver.Messages;
using Gremlin.Net.IntegrationTest.Util;
using Xunit;

namespace Gremlin.Net.IntegrationTest.Driver
{
    public class MessagesTests
    {
        private readonly RequestMessageProvider _requestMessageProvider = new RequestMessageProvider();
        private static readonly string TestHost = ConfigProvider.Configuration["TestServerIpAddress"];
        private static readonly int TestPort = Convert.ToInt32(ConfigProvider.Configuration["TestServerPort"]);

        [Fact]
        public async Task ShouldUseAliasForTraversalSource()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var aliasTraversalSource = "g2";
                var aliases = new Dictionary<string, string> {{aliasTraversalSource, "g"}};
                var gremlinScript = $"{aliasTraversalSource}.V().count()";
                var requestMsg =
                    RequestMessage.Build(Tokens.OpsEval)
                        .AddArgument(Tokens.ArgsAliases, aliases)
                        .AddArgument(Tokens.ArgsGremlin, gremlinScript)
                        .Create();

                var result = await gremlinClient.SubmitWithSingleResultAsync<long>(requestMsg);

                Assert.NotNull(result);
            }
        }

        [Fact]
        public async Task ShouldThrowForInvalidOperation()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var ivalidOperationName = "invalid";
                var requestMsg = RequestMessage.Build(ivalidOperationName).Create();

                var thrownException =
                    await Assert.ThrowsAsync<ResponseException>(() => gremlinClient.SubmitAsync<dynamic>(requestMsg));

                Assert.Contains("MalformedRequest", thrownException.Message);
                Assert.Contains(ivalidOperationName, thrownException.Message);
            }
        }

        [Fact]
        public async Task ShouldThrowForInvalidProcessor()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var invalidProcessorName = "invalid";
                var requestMsg = RequestMessage.Build("").Processor(invalidProcessorName).Create();

                var thrownException =
                    await Assert.ThrowsAsync<ResponseException>(() => gremlinClient.SubmitAsync<dynamic>(requestMsg));

                Assert.Contains("InvalidRequestArguments", thrownException.Message);
                Assert.Contains(invalidProcessorName, thrownException.Message);
                Assert.Contains("OpProcessor", thrownException.Message);
            }
        }

        [Fact]
        public async Task ShouldUseSpecifiedScriptEvaluationTimeout()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                const long timeOutInMs = 1L;
                const int scriptSleepTimeInMs = 5000;
                var sleepScript = _requestMessageProvider.GetSleepGremlinScript(scriptSleepTimeInMs);

                var requestMsg =
                    RequestMessage.Build(Tokens.OpsEval)
                        .AddArgument(Tokens.ArgsGremlin, sleepScript)
                        .AddArgument(Tokens.ArgsEvalTimeout, timeOutInMs)
                        .Create();
                var evaluationStopWatch = new Stopwatch();
                evaluationStopWatch.Start();

                var thrownException =
                    await Assert.ThrowsAsync<ResponseException>(() => gremlinClient.SubmitAsync(requestMsg));

                evaluationStopWatch.Stop();
                Assert.Contains("ServerTimeout", thrownException.Message);
                Assert.Contains(timeOutInMs.ToString(), thrownException.Message);
                Assert.True(evaluationStopWatch.ElapsedMilliseconds < scriptSleepTimeInMs);
            }
        }

        [Fact]
        public async Task ShouldThrowForUnsupportedLanguage()
        {
            var gremlinServer = new GremlinServer(TestHost, TestPort);
            using (var gremlinClient = new GremlinClient(gremlinServer))
            {
                var unknownLanguage = "unknown";
                var requestMsg =
                    RequestMessage.Build(Tokens.OpsEval)
                        .AddArgument(Tokens.ArgsGremlin, "1")
                        .AddArgument(Tokens.ArgsLanguage, unknownLanguage)
                        .Create();

                var thrownException =
                    await Assert.ThrowsAsync<ResponseException>(() => gremlinClient.SubmitAsync(requestMsg));

                Assert.Contains("ScriptEvaluationError", thrownException.Message);
                Assert.Contains(unknownLanguage, thrownException.Message);
            }
        }
    }
}


text:
package org.drip.market.exchange;

/*
 * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 */

/*!
 * Copyright (C) 2016 Lakshmi Krishnamurthy
 * Copyright (C) 2015 Lakshmi Krishnamurthy
 *
 *  This file is part of DRIP, a free-software/open-source library for buy/side financial/trading model
 *  	libraries targeting analysts and developers
 *  	https://lakshmidrip.github.io/DRIP/
 *
 *  DRIP is composed of four main libraries:
 *
 *  - DRIP Fixed Income - https://lakshmidrip.github.io/DRIP-Fixed-Income/
 *  - DRIP Asset Allocation - https://lakshmidrip.github.io/DRIP-Asset-Allocation/
 *  - DRIP Numerical Optimizer - https://lakshmidrip.github.io/DRIP-Numerical-Optimizer/
 *  - DRIP Statistical Learning - https://lakshmidrip.github.io/DRIP-Statistical-Learning/
 *
 *  - DRIP Fixed Income: Library for Instrument/Trading Conventions, Treasury Futures/Options,
 *  	Funding/Forward/Overnight Curves, Multi-Curve Construction/Valuation, Collateral Valuation and XVA
 *  	Metric Generation, Calibration and Hedge Attributions, Statistical Curve Construction, Bond RV
 *  	Metrics, Stochastic Evolution and Option Pricing, Interest Rate Dynamics and Option Pricing, LMM
 *  	Extensions/Calibrations/Greeks, Algorithmic Differentiation, and Asset Backed Models and Analytics.
 *
 *  - DRIP Asset Allocation: Library for model libraries for MPT framework, Black Litterman Strategy
 *  	Incorporator, Holdings Constraint, and Transaction Costs.
 *
 *  - DRIP Numerical Optimizer: Library for Numerical Optimization and Spline Functionality.
 *
 *  - DRIP Statistical Learning: Library for Statistical Evaluation and Machine Learning.
 *
 *  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.
 */

/**
 * TreasuryFuturesConventionContainer holds the Details of the Treasury Futures Contracts.
 *
 * @author Lakshmi Krishnamurthy
 */

public class TreasuryFuturesConventionContainer {
	private static final java.util.Map<java.lang.String, org.drip.market.exchange.TreasuryFuturesConvention>
		_mapFutures = new
			java.util.TreeMap<java.lang.String, org.drip.market.exchange.TreasuryFuturesConvention>();

	/**
	 * Initialize the Bond Futures Convention Container with the Conventions
	 *
	 * @return TRUE - The Bond Futures Convention Container successfully initialized with the Conventions
	 */

	public static final boolean Init()
	{
		int[] aiStandardDeliveryMonth = {org.drip.analytics.date.DateUtil.FEBRUARY,
			org.drip.analytics.date.DateUtil.MAY, org.drip.analytics.date.DateUtil.AUGUST,
				org.drip.analytics.date.DateUtil.NOVEMBER};

		try {
			_mapFutures.put ("AUD-BANK-BILLS-3M", new org.drip.market.exchange.TreasuryFuturesConvention
				("AUD-BANKBILLS-3M", new java.lang.String[] {"AUD-BANKBILLS-3M"}, "AUD", "AUD", "3M",
					1000000., 0.03125, 100000., new java.lang.String[] {"ASX"}, "BANK", "BILLS", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_WEEK_DAY, false,
								-1, org.drip.analytics.date.DateUtil.FRIDAY, 2, -1), new
									org.drip.market.exchange.TreasuryFuturesEligibility ("85D", "95D", new
										java.lang.String[]
											{"Australia and New Zealand Banking Group Limited",
												"Commonwealth Bank of Australia",
													"National Australia Bank Limited",
														"Westpac Banking Corporation"}, 0.), new
															org.drip.market.exchange.TreasuryFuturesSettle (1, 1,
																0, 0,
																	org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_FLAT, false,
					java.lang.Double.NaN, java.lang.Double.NaN, aiStandardDeliveryMonth)));

			_mapFutures.put ("AUD-TREASURY-BOND-3Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("AUD-TREASURY-BOND-3Y", new java.lang.String[] {"YMA"}, "AUD", "AUD", "3Y", 100000., 0.03125,
					0., new java.lang.String[] {"SFE"}, "TREASURY", "BOND", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_WEEK_DAY, false,
								-1, org.drip.analytics.date.DateUtil.FRIDAY, 2, -1), new
									org.drip.market.exchange.TreasuryFuturesEligibility ("2Y", "4Y", new
										java.lang.String[] {}, 0.), new
											org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 0,
												org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_CASH,
													org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_AUD_BOND_FUTURES_STYLE,
				false, java.lang.Double.NaN, java.lang.Double.NaN, aiStandardDeliveryMonth)));

			_mapFutures.put ("AUD-TREASURY-BOND-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("AUD-TREASURY-BOND-10Y", new java.lang.String[] {"XMA"}, "AUD", "AUD", "10Y", 100000.,
					0.03125, 0., new java.lang.String[] {"SFE"}, "TREASURY", "BOND", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_WEEK_DAY, false,
								-1, org.drip.analytics.date.DateUtil.FRIDAY, 2, -1), new
									org.drip.market.exchange.TreasuryFuturesEligibility ("8Y", "12Y", new
										java.lang.String[] {}, 0.), new
											org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 0,
												org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_CASH,
													org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_AUD_BOND_FUTURES_STYLE,
				false, java.lang.Double.NaN, java.lang.Double.NaN, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-BOND-ULTRA", new org.drip.market.exchange.TreasuryFuturesConvention
				("ULTRA T-BOND", new java.lang.String[] {"UB", "UL", "UBE"}, "USD", "USD", "ULTRA", 100000.,
					0.03125, 0., new java.lang.String[] {"CBOT"}, "TREASURY", "BOND", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								7, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("25Y",
									"MAX", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (1, 1, -1, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-BOND-30Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("USD 30-YR BOND", new java.lang.String[] {"ZB", "US"}, "USD", "USD", "30Y", 100000., 0.03125,
					0., new java.lang.String[] {"CBOT"}, "TREASURY", "BOND", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								7, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("15Y",
									"25Y", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (1, 1, -1, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-NOTE-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("USD 10-YR NOTE", new java.lang.String[] {"ZN", "TY"}, "USD", "USD", "10Y", 100000., 0.03125,
					0., new java.lang.String[] {"CBOT"}, "TREASURY", "NOTE", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								7, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("78M",
									"10Y", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (1, 1, -1, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-NOTE-5Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("USD 5-YR NOTE", new java.lang.String[] {"ZF", "FV"}, "USD", "USD", "5Y", 100000., 0.03125,
					0., new java.lang.String[] {"CBOT"}, "TREASURY", "NOTE", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								0, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("50M",
									"63M", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (3, 3, 0, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-NOTE-3Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("USD 3-YR NOTE", new java.lang.String[] {"Z3N", "3YR"}, "USD", "USD", "3Y", 200000., 0.03125,
					0., new java.lang.String[] {"CBOT"}, "TREASURY", "NOTE", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								0, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("33M",
									"3Y", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("USD-TREASURY-NOTE-2Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("USD 2-YR NOTE", new java.lang.String[] {"ZT", "TU"}, "USD", "USD", "2Y", 200000., 0.03125,
					0., new java.lang.String[] {"CBOT"}, "TREASURY", "NOTE", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								0, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("21M",
									"2Y", new java.lang.String[] {"US Government Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("EUR-EURO-BUXL-30Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("EUR EURO-BUXL", new java.lang.String[] {"BUXL"}, "EUR", "EUR", "30Y", 100000., 0.03125, 0.,
					new java.lang.String[] {"EUREX"}, "EURO", "BUXL", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								10, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("24Y",
									"35Y", new java.lang.String[] {"EUR-Germany BUXL Bonds"}, 5000000000.),
										new org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 2,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.04, 0.04, aiStandardDeliveryMonth)));

			_mapFutures.put ("EUR-EURO-BUND-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("EUR EURO-BUND", new java.lang.String[] {"BUND"}, "EUR", "EUR", "10Y", 100000., 0.03125, 0.,
					new java.lang.String[] {"EUREX", "NLX"}, "EURO", "BUND", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								10, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("102M",
									"126M", new java.lang.String[] {"EUR-Germany BUND Bonds"}, 5000000000.),
										new org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 2,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("EUR-EURO-BOBL-5Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("EUR EURO-BUND", new java.lang.String[] {"BOBL"}, "EUR", "EUR", "5Y", 100000., 0.03125, 0.,
					new java.lang.String[] {"EUREX", "NLX"}, "EURO", "BOBL", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								10, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("54M",
									"66M", new java.lang.String[] {"EUR-Germany BOBL Bonds"}, 5000000000.),
										new org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 2,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("EUR-EURO-SCHATZ-2Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("EUR EURO-BUND", new java.lang.String[] {"SCHATZ"}, "EUR", "EUR", "2Y", 100000., 0.03125, 0.,
					new java.lang.String[] {"EUREX", "NLX"}, "EURO", "SCHATZ", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								10, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("21M",
									"27M", new java.lang.String[] {"EUR-Germany SCHATZ Bonds"}, 5000000000.),
										new org.drip.market.exchange.TreasuryFuturesSettle (1, 1, 0, 2,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("EUR-TREASURY-BONO-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("EUR 10Y BONO", new java.lang.String[] {"10Y-BONO"}, "EUR", "EUR", "10Y", 100000., 0.03125,
					0., new java.lang.String[] {"MEFF", "SENAF"}, "TREASURY", "BONO", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_SPECIFIC_DAY_OF_MONTH,
				false, 7, -1, -1, 10), new org.drip.market.exchange.TreasuryFuturesEligibility ("102M", "MAX",
					new java.lang.String[] {"EUR BONO"}, 0.), new org.drip.market.exchange.TreasuryFuturesSettle
						(1, 1, -2, -2,
							org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
								org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR,
				false, 0.06, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("GBP-SHORT-GILT-2Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("GBP SHORT-GILT", new java.lang.String[] {"SHORT-GILT"}, "GBP", "GBP", "2Y", 100000.,
					0.03125, 0., new java.lang.String[] {"LIFFE"}, "SHORT", "GILT", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								2, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("18M",
									"39M", new java.lang.String[] {"GBP Short GILT Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (0, 22, -2, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.04, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("GBP-MEDIUM-GILT-5Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("GBP MEDIUM-GILT", new java.lang.String[] {"MEDIUM-GILT"}, "GBP", "GBP", "5Y", 100000.,
					0.03125, 0., new java.lang.String[] {"LIFFE"}, "MEDIUM", "GILT", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								2, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("4Y",
									"75M", new java.lang.String[] {"GBP Medium GILT Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (0, 22, -2, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.04, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("GBP-LONG-GILT-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("GBP LONG-GILT", new java.lang.String[] {"LONG-GILT"}, "GBP", "GBP", "10Y", 100000., 0.03125,
					0., new java.lang.String[] {"LIFFE", "NLX"}, "MEDIUM", "GILT", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_EDGE_LAG, true,
								2, -1, -1, -1), new org.drip.market.exchange.TreasuryFuturesEligibility ("105M",
									"13Y", new java.lang.String[] {"GBP Long GILT Bonds"}, 0.), new
										org.drip.market.exchange.TreasuryFuturesSettle (0, 22, -2, 0,
											org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
				org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR, false,
					0.03, 0.06, aiStandardDeliveryMonth)));

			_mapFutures.put ("JPY-TREASURY-JGB-5Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("JPY 5Y JGB", new java.lang.String[] {"5Y-JGB"}, "JPY", "JPY", "5Y", 1000000000., 0.03125,
					0., new java.lang.String[] {"TSE"}, "TREASURY", "JGB", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_SPECIFIC_DAY_OF_MONTH,
				true, 7, -1, -1, 20), new org.drip.market.exchange.TreasuryFuturesEligibility ("4Y", "63M", new
					java.lang.String[] {"JPY JGB"}, 0.), new org.drip.market.exchange.TreasuryFuturesSettle (1,
						1, 0, -7, org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
							org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR,
				false, 0.03, 0.03, aiStandardDeliveryMonth)));

			_mapFutures.put ("JPY-TREASURY-JGB-10Y", new org.drip.market.exchange.TreasuryFuturesConvention
				("JPY 10Y JGB", new java.lang.String[] {"10Y-JGB"}, "JPY", "JPY", "10Y", 1000000000., 0.03125,
					0., new java.lang.String[] {"TSE"}, "TREASURY", "JGB", new
						org.drip.analytics.eventday.DateInMonth
							(org.drip.analytics.eventday.DateInMonth.INSTANCE_GENERATOR_RULE_SPECIFIC_DAY_OF_MONTH,
				true, 7, -1, -1, 20), new org.drip.market.exchange.TreasuryFuturesEligibility ("7Y", "10Y", new
					java.lang.String[] {"JPY JGB"}, 0.), new org.drip.market.exchange.TreasuryFuturesSettle (1,
						1, 0, -7, org.drip.market.exchange.TreasuryFuturesSettle.SETTLE_TYPE_PHYSICAL_DELIVERY,
							org.drip.market.exchange.TreasuryFuturesSettle.QUOTE_REFERENCE_INDEX_CONVERSION_FACTOR,
				false, 0.06, 0.06, aiStandardDeliveryMonth)));
		} catch (java.lang.Exception e) {
			e.printStackTrace();

			return false;
		}

		return true;
	}

	/**
	 * Retrieve the Treasury Futures Convention from the Currency, the Type, the Sub-type, and the Maturity
	 *	Tenor
	 *
	 * @param strCurrency The Currency
	 * @param strUnderlierType The Underlier Type
	 * @param strUnderlierSubtype The Underlier Sub-type
	 * @param strMaturityTenor The Maturity Tenor
	 *
	 * @return The Treasury Futures Instance
	 */

	public static final org.drip.market.exchange.TreasuryFuturesConvention FromJurisdictionTypeMaturity (
		final java.lang.String strCurrency,
		final java.lang.String strUnderlierType,
		final java.lang.String strUnderlierSubtype,
		final java.lang.String strMaturityTenor)
	{
		if (null == strCurrency || strCurrency.isEmpty() || null == strUnderlierType ||
			strUnderlierType.isEmpty() || null == strUnderlierSubtype || strUnderlierSubtype.isEmpty() ||
				null == strMaturityTenor || strMaturityTenor.isEmpty())
			return null;

		java.lang.String strKey = strCurrency + "-" + strUnderlierType + "-" + strUnderlierSubtype + "-" +
			strMaturityTenor;

		return _mapFutures.containsKey (strKey) ? _mapFutures.get (strKey) : null;
	}
}


text:
import LocalPeer from './LocalPeer';
import RemotePeer from './RemotePeer';
import { provideConnection } from './rtcconnectionprovider';
export { LocalPeer, provideConnection, RemotePeer };


text:
(function() {
    var game = new Phaser.Game(this, 'game', 800, 600, preload, create, null, render);

    var colorWheel: Phaser.Sprite,
        selected: Phaser.Sprite,
        color: String = '#CCA22B';
    var offset = {
        x: 300 - 578 / 2,
        y: 300 - 550 / 2
    };
    var rect: Phaser.Rectangle,
        rectSize: Number = 24;

    function preload() {
        game.load.image('color-wheel', 'assets/pics/color-wheel.png');

    }
    function create() {
        // Create color wheel texture.
        colorWheel = game.add.dynamicTexture(578, 550);
        colorWheel.pasteImage('color-wheel');

        // Create a rectangle shows the color you just selected.
        rect = new Phaser.Rectangle(0, 0, rectSize, rectSize);
        selected = game.add.sprite(600, 430);
        selected.width = rectSize;
        selected.height = rectSize;
        selected.texture.loadDynamicTexture(game.add.dynamicTexture(rectSize, rectSize));
        selected.texture.dynamicTexture.fillRect(rect, color);

        // Get the color under the position you tapped or clicked.
        var pos = {};
        game.input.onTap.add(function(pointer) {
            pos.x = pointer.position.x - offset.x;
            pos.y = pointer.position.y - offset.y;
            color = Phaser.ColorUtils.RGBtoWebstring(colorWheel.getPixel32(pos.x, pos.y));

            // Set the rectangle's color to new selected one.
            selected.texture.dynamicTexture.fillRect(rect, color);
        });

        // Set the background color to white.
        game.stage.backgroundColor = '#fff';
}
    function render() {
        colorWheel.render(offset.x, offset.y);

        Phaser.DebugUtils.context.fillStyle = '#000';
        Phaser.DebugUtils.context.fillText('Tap or click the color wheel to select a color.', 480, 52);
        Phaser.DebugUtils.context.fillText(color, 646, 452);
    }
})();


text:
<!DOCTYPE html>

<title>Google Sheets Test</title>
<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />


text:
/* global jQuery,QUnit,assert */

// Load synchronously to avoid QUnit issue where tests run before QUnit is loaded
jQuery.sap.require("sap.ui.thirdparty.qunit");

// put qunit-coverage last so library files don't get measured  (we load StepDefinitions, even though we don't have to,
// so that it doesn't appear in the code coverage list, knowing that the user will need to load it)
sap.ui.define([
  'jquery.sap.global', 'sap/ui/base/Object', "sap/ui/test/gherkin/GherkinTestGenerator",
  "sap/ui/test/gherkin/StepDefinitions", "sap/ui/qunit/qunit-css", "sap/ui/qunit/qunit-junit",
  "sap/ui/qunit/qunit-coverage"
], function($, UI5Object, GherkinTestGenerator) {
  'use strict';

  /**
   * Dynamically generates and executes QUnit tests based on a Gherkin feature file and step definitions
   *
   * Logs activity to QUnit, and some debug information to the console with the prefix "[GHERKIN]"
   *
   * @author Jonathan Benn
   * @alias sap.ui.test.gherkin.qUnitTestHarness
   * @namespace
   * @since 1.40
   * @public
   * @static
   */
  var qUnitTestHarness = {

    /**
     * Dynamically generates and executes QUnit tests
     *
     * @param {object} args - the arguments to the function
     * @param {string} args.featurePath - the path to the Gherkin feature file to parse, as a SAPUI5 module path. The
     *                                    ".feature" extension is assumed and should not be included. See
     *                                    {@link jQuery.sap#registerModulePath}
     * @param {function} args.steps - the constructor function of type sap.ui.test.gherkin.StepDefinitions
     * @public
     * @throws {Error} for invalid parameters - parameter does not match the expected type
     * @function
     * @static
     */
    test: function(args) {

      if ($.type(args) !== "object") {
        throw new Error("qUnitTestHarness.test: input all arguments via a single object");
      }

      if ($.type(args.featurePath) !== "string") {
        throw new Error("qUnitTestHarness.test: parameter 'featurePath' must be a valid string");
      }

      if ($.type(args.steps) !== "function") {
        throw new Error("qUnitTestHarness.test: parameter 'steps' must be a valid StepDefinitions constructor");
      }

      var oTestGenerator = new GherkinTestGenerator(args.featurePath, args.steps);
      var oFeatureTest = oTestGenerator.generate();

      QUnit.module(oFeatureTest.name, {
        setup: function() {
          oTestGenerator.setUp();
        },
        teardown: function() {
          oTestGenerator.tearDown();
        }
      });

      $.sap.log.info("[GHERKIN] Running feature: '" + oFeatureTest.name + "'");
      oFeatureTest.testScenarios.forEach(function(oTestScenario) {
        var fnTestFunction = (!oTestScenario.wip) ? QUnit.test : QUnit.skip;
        fnTestFunction(oTestScenario.name, function() {
          $.sap.log.info("[GHERKIN] Running scenario: '" + oTestScenario.name + "'");
          oTestScenario.testSteps.forEach(function(oTestStep) {
            $.sap.log.info("[GHERKIN] Running step: text='" + oTestStep.text + "' regex='" + oTestStep.regex + "'");
            assert.ok(oTestStep.isMatch, oTestStep.text);
            if (oTestStep.isMatch) {
              QUnit.config.current.assertions.pop(); // don't break QUnit expect() behaviour
            }
            oTestGenerator.execute(oTestStep);
          });
        });
      });
    }
  };

  return qUnitTestHarness;
}, /* bExport= */ true);


text:
<!--

    Copyright 2012 International Business Machines Corp.

    See the NOTICE file distributed with this work for additional information
    regarding copyright ownership. 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.

-->
<job id="5.Child" parent="5.Parent" xmlns="http://batch.jsr352/jsl">
	<properties merge="true">
		<property name="sharedProp" value="expected"/>
	</properties>
	<listeners merge="true">
		<listener ref="sharedRef">
			<properties>
				<property name="sharedRefProp" value="expected"/>
			</properties>
		</listener>
	</listeners>
</job>


text:
'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var toPositiveInteger = require('../internals/to-positive-integer');
var createIteratorProxy = require('../internals/iterator-create-proxy');

var IteratorProxy = createIteratorProxy(function (args) {
  var iterator = this.iterator;
  var next = this.next;
  var result, done;
  while (this.remaining) {
    this.remaining--;
    result = anObject(next.call(iterator));
    done = this.done = !!result.done;
    if (done) return;
  }
  result = anObject(next.apply(iterator, args));
  done = this.done = !!result.done;
  if (!done) return result.value;
});

$({ target: 'Iterator', proto: true, real: true }, {
  drop: function drop(limit) {
    return new IteratorProxy({
      iterator: anObject(this),
      remaining: toPositiveInteger(limit)
    });
  }
});


text:
import * as nls from 'vs/nls';
import * as dom from 'vs/base/browser/dom';
import * as errors from 'vs/base/common/errors';
import { IDisposable, dispose } from 'vs/base/common/lifecycle';
import { IQuickOpenService } from 'vs/platform/quickOpen/common/quickOpen';
import { IThemeService } from 'vs/platform/theme/common/themeService';
import { IStatusbarItem } from 'vs/workbench/browser/parts/statusbar/statusbar';
import { IDebugService, State, IDebugConfiguration } from 'vs/workbench/parts/debug/common/debug';
import { Themable, STATUS_BAR_FOREGROUND } from 'vs/workbench/common/theme';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';

const $ = dom.$;

export class DebugStatus extends Themable implements IStatusbarItem {
	private toDispose: IDisposable[];
	private container: HTMLElement;
	private statusBarItem: HTMLElement;
	private label: HTMLElement;
	private icon: HTMLElement;
	private showInStatusBar: string;

	constructor(
		@IQuickOpenService private quickOpenService: IQuickOpenService,
		@IDebugService private debugService: IDebugService,
		@IThemeService themeService: IThemeService,
		@IConfigurationService configurationService: IConfigurationService
	) {
		super(themeService);
		this.toDispose = [];
		this.toDispose.push(this.debugService.getConfigurationManager().onDidSelectConfiguration(e => {
			this.setLabel();
		}));
		this.toDispose.push(this.debugService.onDidChangeState(state => {
			if (state !== State.Inactive && this.showInStatusBar === 'onFirstSessionStart') {
				this.doRender();
			}
		}));
		this.showInStatusBar = configurationService.getValue<IDebugConfiguration>('debug').showInStatusBar;
		this.toDispose.push(configurationService.onDidChangeConfiguration(e => {
			if (e.affectsConfiguration('debug.showInStatusBar')) {
				this.showInStatusBar = configurationService.getValue<IDebugConfiguration>('debug').showInStatusBar;
				if (this.showInStatusBar === 'never' && this.statusBarItem) {
					this.statusBarItem.hidden = true;
				} else {
					if (this.statusBarItem) {
						this.statusBarItem.hidden = false;
					}
					if (this.showInStatusBar === 'always') {
						this.doRender();
					}
				}
			}
		}));
	}

	protected updateStyles(): void {
		super.updateStyles();
		if (this.icon) {
			this.icon.style.backgroundColor = this.getColor(STATUS_BAR_FOREGROUND);
		}
	}

	public render(container: HTMLElement): IDisposable {
		this.container = container;
		if (this.showInStatusBar === 'always') {
			this.doRender();
		}
		// noop, we render when we decide is best
		return this;
	}

	private doRender(): void {
		if (!this.statusBarItem && this.container) {
			this.statusBarItem = dom.append(this.container, $('.debug-statusbar-item'));
			this.toDispose.push(dom.addDisposableListener(this.statusBarItem, 'click', () => {
				this.quickOpenService.show('debug ').done(undefined, errors.onUnexpectedError);
			}));
			this.statusBarItem.title = nls.localize('selectAndStartDebug', "Select and start debug configuration");
			const a = dom.append(this.statusBarItem, $('a'));
			this.icon = dom.append(a, $('.icon'));
			this.label = dom.append(a, $('span.label'));
			this.setLabel();
			this.updateStyles();
		}
	}

	private setLabel(): void {
		if (this.label && this.statusBarItem) {
			const manager = this.debugService.getConfigurationManager();
			const name = manager.selectedName || '';
			this.label.textContent = manager.getLaunches().length > 1 ? `${name} (${manager.selectedLaunch.workspace.name})` : name;
		}
	}

	public dispose(): void {
		super.dispose();
		this.toDispose = dispose(this.toDispose);
	}
}


text:
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Runtime.CompilerServices;

namespace Twin.Model {
    class Clipboard {
		public static bool Empty {
			get {
				return (bool)STAHelper.Invoke(
					delegate() {
						return System.Windows.Clipboard.GetDataObject() == null;
					}
				);
			}
			set {
				STAHelper.Invoke(
					delegate() {
	            		if (value)
	            		    System.Windows.Clipboard.Clear();
			            else
    			            throw new ArgumentOutOfRangeException("value", value, "Cannot set Empty to false!");
					}
				);
			}
		}
		public static string Text {
			get {
				return (string)STAHelper.Invoke(
					delegate() {
						if(System.Windows.Clipboard.ContainsText())
			                return System.Windows.Clipboard.GetText();
   				        return null;
					}
				);
			}
			set {
				STAHelper.Invoke(
					delegate() {
			            if (value == null)
			                System.Windows.Clipboard.Clear();
		    	        else
    		    	        System.Windows.Clipboard.SetText(value);
					}
				);
			}
		}
	}
}


text:
testcommand="${1} ${2}/manage.py test"
posargs="${@:3}"

tagarg="--exclude-tag selenium --exclude-tag integration --exclude-tag plugin-test"

if [[ -n "${WITH_SELENIUM}" ]]
then
  tagarg="--tag selenium"
elif [[ -n "${INTEGRATION_TESTS}" ]]
then
  tagarg="--tag integration"
#else
#  tag="unit"
fi

# Attempt to identify if any of the arguments passed from tox is a test subset
if [ -n "$posargs" ]; then
  for arg in "$posargs"
  do
    if [ ${arg:0:1} != "-" ]; then
      subset=$arg
    fi
  done
fi

# If we are running a test subset, supply the correct settings file.
# If not, simply run the entire test suite.
if [ -n "$subset" ]; then
  project="${subset%%.*}"
  if [ $project == "horizon" ]; then
    $testcommand --settings=horizon.test.settings --verbosity 2 $tagarg $posargs
  elif [ $project == "openstack_dashboard" ]; then
    $testcommand --settings=openstack_dashboard.test.settings --verbosity 2 $tagarg $posargs
  elif [ $project == "openstack_auth" ]; then
    $testcommand --settings=openstack_auth.tests.settings --verbosity 2 $tagarg $posargs
  elif [ $project == "plugin-test" ]; then
    $testcommand --settings=openstack_dashboard.test.settings --verbosity 2 --tag plugin-test openstack_dashboard.test.test_plugins
  fi
else
  $testcommand horizon --settings=horizon.test.settings --verbosity 2 $tagarg $posargs
  horizon_tests=$?
  $testcommand openstack_dashboard --settings=openstack_dashboard.test.settings --verbosity 2 $tagarg $posargs
  openstack_dashboard_tests=$?
  $testcommand openstack_auth --settings=openstack_auth.tests.settings --verbosity 2 $tagarg $posargs
  auth_tests=$?
  $testcommand --settings=openstack_dashboard.test.settings --verbosity 2 --tag plugin-test openstack_dashboard.test.test_plugins
  plugin_tests=$?
  # we have to tell tox if either of these test runs failed
  if [[ $horizon_tests != 0 || $openstack_dashboard_tests != 0 || \
    $auth_tests != 0 || $plugin_tests != 0 ]]; then
    exit 1;
  fi
fi


text:
package verifyowners

import (
	"fmt"
	"io/ioutil"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"

	"github.com/sirupsen/logrus"

	"k8s.io/apimachinery/pkg/util/sets"
	"k8s.io/test-infra/prow/git"
	"k8s.io/test-infra/prow/github"
	"k8s.io/test-infra/prow/labels"
	"k8s.io/test-infra/prow/pluginhelp"
	"k8s.io/test-infra/prow/plugins"
	"k8s.io/test-infra/prow/plugins/golint"
	"k8s.io/test-infra/prow/repoowners"
)

const (
	// PluginName defines this plugin's registered name.
	PluginName     = "verify-owners"
	ownersFileName = "OWNERS"
)

func init() {
	plugins.RegisterPullRequestHandler(PluginName, handlePullRequest, helpProvider)
}

func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {
	pluginHelp := &pluginhelp.PluginHelp{
		Description: fmt.Sprintf("The verify-owners plugin validates %s files if they are modified in a PR. On validation failure it automatically adds the '%s' label to the PR, and a review comment on the incriminating file(s).", ownersFileName, labels.InvalidOwners),
	}
	if config.Owners.LabelsBlackList != nil {
		pluginHelp.Config = map[string]string{
			"": fmt.Sprintf(`The verify-owners plugin will complain if %s files contain any of the following blacklisted labels: %s.`,
				ownersFileName,
				strings.Join(config.Owners.LabelsBlackList, ", ")),
		}
	}
	return pluginHelp, nil
}

type ownersClient interface {
	LoadRepoOwners(org, repo, base string) (repoowners.RepoOwner, error)
}

type githubClient interface {
	AddLabel(org, repo string, number int, label string) error
	CreateComment(owner, repo string, number int, comment string) error
	CreateReview(org, repo string, number int, r github.DraftReview) error
	GetPullRequestChanges(org, repo string, number int) ([]github.PullRequestChange, error)
	RemoveLabel(owner, repo string, number int, label string) error
}

func handlePullRequest(pc plugins.Agent, pre github.PullRequestEvent) error {
	if pre.Action != github.PullRequestActionOpened && pre.Action != github.PullRequestActionReopened && pre.Action != github.PullRequestActionSynchronize {
		return nil
	}
	return handle(pc.GitHubClient, pc.GitClient, pc.Logger, &pre, pc.PluginConfig.Owners.LabelsBlackList)
}

type messageWithLine struct {
	line    int
	message string
}

func handle(ghc githubClient, gc *git.Client, log *logrus.Entry, pre *github.PullRequestEvent, labelsBlackList []string) error {
	org := pre.Repo.Owner.Login
	repo := pre.Repo.Name
	wrongOwnersFiles := map[string]messageWithLine{}

	// Get changes.
	changes, err := ghc.GetPullRequestChanges(org, repo, pre.Number)
	if err != nil {
		return fmt.Errorf("error getting PR changes: %v", err)
	}

	// List modified OWNERS files.
	var modifiedOwnersFiles []github.PullRequestChange
	for _, change := range changes {
		if filepath.Base(change.Filename) == ownersFileName {
			modifiedOwnersFiles = append(modifiedOwnersFiles, change)
		}
	}
	if len(modifiedOwnersFiles) == 0 {
		return nil
	}

	// Clone the repo, checkout the PR.
	r, err := gc.Clone(pre.Repo.FullName)
	if err != nil {
		return err
	}
	defer func() {
		if err := r.Clean(); err != nil {
			log.WithError(err).Error("Error cleaning up repo.")
		}
	}()
	if err := r.CheckoutPullRequest(pre.Number); err != nil {
		return err
	}
	// If we have a specific SHA, use it.
	if pre.PullRequest.Head.SHA != "" {
		if err := r.Checkout(pre.PullRequest.Head.SHA); err != nil {
			return err
		}
	}

	// Check each OWNERS file.
	for _, c := range modifiedOwnersFiles {
		// Try to load OWNERS file.
		path := filepath.Join(r.Dir, c.Filename)
		b, err := ioutil.ReadFile(path)
		if err != nil {
			log.WithError(err).Warningf("Failed to read %s.", path)
			return nil
		}
		if msg := parseOwnersFile(b, c, log, labelsBlackList); msg != nil {
			wrongOwnersFiles[c.Filename] = *msg
		}
	}
	// React if we saw something.
	if len(wrongOwnersFiles) > 0 {
		s := "s"
		if len(wrongOwnersFiles) == 1 {
			s = ""
		}
		if err := ghc.AddLabel(org, repo, pre.Number, labels.InvalidOwners); err != nil {
			return err
		}
		log.Debugf("Creating a review for %d %s file%s.", len(wrongOwnersFiles), ownersFileName, s)
		var comments []github.DraftReviewComment
		for errFile, err := range wrongOwnersFiles {
			comments = append(comments, github.DraftReviewComment{
				Path:     errFile,
				Body:     err.message,
				Position: err.line,
			})
		}
		// Make the review body.
		response := fmt.Sprintf("%d invalid %s file%s", len(wrongOwnersFiles), ownersFileName, s)
		draftReview := github.DraftReview{
			Body:     plugins.FormatResponseRaw(pre.PullRequest.Body, pre.PullRequest.HTMLURL, pre.PullRequest.User.Login, response),
			Action:   github.Comment,
			Comments: comments,
		}
		if pre.PullRequest.Head.SHA != "" {
			draftReview.CommitSHA = pre.PullRequest.Head.SHA
		}
		err := ghc.CreateReview(org, repo, pre.Number, draftReview)
		if err != nil {
			return fmt.Errorf("error creating a review for invalid %s file%s: %v", ownersFileName, s, err)
		}
	} else {
		// Don't bother checking if it has the label...it's a race, and we'll have
		// to handle failure due to not being labeled anyway.
		if err := ghc.RemoveLabel(org, repo, pre.Number, labels.InvalidOwners); err != nil {
			return fmt.Errorf("failed removing %s label: %v", labels.InvalidOwners, err)
		}
	}
	return nil
}

func parseOwnersFile(b []byte, c github.PullRequestChange, log *logrus.Entry, labelsBlackList []string) *messageWithLine {
	var approvers []string
	var labels []string
	// by default we bind errors to line 1
	lineNumber := 1
	simple, err := repoowners.ParseSimpleConfig(b)
	if err != nil || simple.Empty() {
		full, err := repoowners.ParseFullConfig(b)
		if err != nil {
			lineNumberRe, _ := regexp.Compile(`line (\d+)`)
			lineNumberMatches := lineNumberRe.FindStringSubmatch(err.Error())
			// try to find a line number for the error
			if len(lineNumberMatches) > 1 {
				// we're sure it will convert as it passed the regexp already
				absoluteLineNumber, _ := strconv.Atoi(lineNumberMatches[1])
				// we need to convert it to a line number relative to the patch
				al, err := golint.AddedLines(c.Patch)
				if err != nil {
					log.WithError(err).Errorf("Failed to compute added lines in %s: %v", c.Filename, err)
				} else if val, ok := al[absoluteLineNumber]; ok {
					lineNumber = val
				}
			}
			return &messageWithLine{
				lineNumber,
				fmt.Sprintf("Cannot parse file: %v.", err),
			}
		}
		// it's a FullConfig
		for _, config := range full.Filters {
			approvers = append(approvers, config.Approvers...)
			labels = append(labels, config.Labels...)
		}
	} else {
		// it's a SimpleConfig
		approvers = simple.Config.Approvers
		labels = simple.Config.Labels
	}
	// Check labels against blacklist
	if sets.NewString(labels...).HasAny(labelsBlackList...) {
		return &messageWithLine{
			lineNumber,
			fmt.Sprintf("File contains blacklisted labels: %s.", sets.NewString(labels...).Intersection(sets.NewString(labelsBlackList...)).List()),
		}
	}
	// Check approvers isn't empty
	if filepath.Dir(c.Filename) == "." && len(approvers) == 0 {
		return &messageWithLine{
			lineNumber,
			fmt.Sprintf("No approvers defined in this root directory %s file.", ownersFileName),
		}
	}
	return nil
}


text:
public class SLLNode extends Position {

	private SLLNode next;

	public SLLNode(int value) {
		super(value);
	}

	public SLLNode getNext() {
		return next;
	}

	public void setNext(SLLNode next) {
		this.next = next;
	}
}


text:
class AdminAssistant
  class ShowView
    def initialize(record, admin_assistant, action_view)
      @record, @admin_assistant, @action_view =
          record, admin_assistant, action_view
    end

    def column_html(column)
      column.html @record
    end

    def columns
      column_names = @admin_assistant.show_settings.column_names ||
                     @admin_assistant.model_class.columns.map(&:name)
      @admin_assistant.accumulate_columns(column_names).map { |c|
        c.show_view @action_view, @admin_assistant
      }
    end
  end
end


text:
<?php
    namespace Models;

    use Core\Model;
    use Helpers\Password;

    class M_creation_profil extends Model
    {
        function __construct()
        {
            parent::__construct();
        }

        public function Enregistrement($login, $password, $mail)
        {

            $this->db->insert('utilisateur', array('login'=> $login, 'password'=> Password::make($password), 'mail'=> $mail)) ;

            return true;
        }
    }
?>


text:
#pragma once

#include "dcgf.h"

class C3DShadowVolume : public CBBase
{
public:
	C3DShadowVolume(CBGame* inGame);
	virtual ~C3DShadowVolume(void);

	HRESULT AddMesh(LPD3DXMESH Mesh, DWORD* Adjacency, D3DXMATRIX* ModelMat, D3DXVECTOR3* Light, float ExtrusionDepth);
	HRESULT Reset();

	HRESULT RenderToStencilBuffer();
	HRESULT RenderToScene();

	HRESULT SetColor(DWORD Color);

private:
	HRESULT Render();
	inline void AddVertex(D3DXVECTOR3* Vertex);
	DWORD m_Color;
	HRESULT InitMask();
	D3DXVECTOR3* m_Vertices; // Vertex data for rendering shadow volume
	int m_VertBufferSize;
	DWORD       m_NumVertices;
	LPDIRECT3DVERTEXBUFFER  m_StencilMaskVB;

};


text: class Barber < ActiveRecord::Base; end


text:
name: Feature Request
about: Suggest an idea for new or improved behavior.
title: "Brief summary of the proposed feature"
labels: 'type: feature request'

---

<!--

Thanks for stopping by to let us know something could be better!

**PLEASE READ**: If you have a support contract with Google, please create an
issue in the [support console](https://cloud.google.com/support/) instead of
filing on GitHub. This will ensure a timely response.

Please run down the following list and make sure you've tried the usual "quick fixes":

  - Search the issues already opened: https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory/issues
  - Check for answers on StackOverflow: https://stackoverflow.com/questions/tagged/google-cloud-sql

If you are still having issues, please include as much information as possible:

-->
## Feature Description
A clear and concise description of what feature you would like to see, and why it would be useful to have added.

## Alternatives Considered
Are there any workaround or third party tools to replicate this behavior? Why would adding this feature be preferred over them?

## Additional Context
Please reference any other issues, PRs, descriptions, or screenshots here.


text:
@interface ThumbImageCollectionViewCell : UICollectionViewCell
- (void)setDataWithModel:(HMPhotoModel *)model;
@end


text:
<?php
/**
 * FA.php
 * @author Revin Roman
 * @link https://rmrevin.ru
 */

namespace rmrevin\yii\fontawesome;

/**
 * Class FA
 * @package rmrevin\yii\fontawesome
 */
class FA extends FontAwesome
{

    /**
     * Get all icon constants for dropdown list in example
     * @param bool $html whether to render icon as array value prefix
     * @return array
     */
    public static function getConstants($html = false)
    {
        $result = [];
        foreach ((new \ReflectionClass(get_class()))->getConstants() as $constant) {
            $key = static::$cssPrefix . ' ' . static::$cssPrefix . '-' . $constant;

            $result[$key] = ($html)
                ? static::icon($constant) . '  ' . $constant
                : $constant;
        }

        return $result;
    }

    /**
     * How I saved from: http://fortawesome.github.io/Font-Awesome/cheatsheet/
     *
     * $.each($('.col-md-4.col-sm-6.col-lg-3').text().split(' '), function (i, item) {
     *   if(item.indexOf('fa-') !== -1) {
     *     var icon = item.substr(3).replace(/(\n)/g, '');
     *     console.log('const _' + icon.replace(/-/gi, '_').toUpperCase() + " = '" + icon + "';")
     *   }
     * });
     */

    const _500PX = '500px';
    const _ADJUST = 'adjust';
    const _ADN = 'adn';
    const _ALIGN_CENTER = 'align-center';
    const _ALIGN_JUSTIFY = 'align-justify';
    const _ALIGN_LEFT = 'align-left';
    const _ALIGN_RIGHT = 'align-right';
    const _AMAZON = 'amazon';
    const _AMBULANCE = 'ambulance';
    const _AMERICAN_SIGN_LANGUAGE_INTERPRETING = 'american-sign-language-interpreting';
    const _ANCHOR = 'anchor';
    const _ANDROID = 'android';
    const _ANGELLIST = 'angellist';
    const _ANGLE_DOUBLE_DOWN = 'angle-double-down';
    const _ANGLE_DOUBLE_LEFT = 'angle-double-left';
    const _ANGLE_DOUBLE_RIGHT = 'angle-double-right';
    const _ANGLE_DOUBLE_UP = 'angle-double-up';
    const _ANGLE_DOWN = 'angle-down';
    const _ANGLE_LEFT = 'angle-left';
    const _ANGLE_RIGHT = 'angle-right';
    const _ANGLE_UP = 'angle-up';
    const _APPLE = 'apple';
    const _ARCHIVE = 'archive';
    const _AREA_CHART = 'area-chart';
    const _ARROW_CIRCLE_DOWN = 'arrow-circle-down';
    const _ARROW_CIRCLE_LEFT = 'arrow-circle-left';
    const _ARROW_CIRCLE_O_DOWN = 'arrow-circle-o-down';
    const _ARROW_CIRCLE_O_LEFT = 'arrow-circle-o-left';
    const _ARROW_CIRCLE_O_RIGHT = 'arrow-circle-o-right';
    const _ARROW_CIRCLE_O_UP = 'arrow-circle-o-up';
    const _ARROW_CIRCLE_RIGHT = 'arrow-circle-right';
    const _ARROW_CIRCLE_UP = 'arrow-circle-up';
    const _ARROW_DOWN = 'arrow-down';
    const _ARROW_LEFT = 'arrow-left';
    const _ARROW_RIGHT = 'arrow-right';
    const _ARROW_UP = 'arrow-up';
    const _ARROWS = 'arrows';
    const _ARROWS_ALT = 'arrows-alt';
    const _ARROWS_H = 'arrows-h';
    const _ARROWS_V = 'arrows-v';
    const _ASL_INTERPRETING = 'asl-interpreting';
    const _ASSISTIVE_LISTENING_SYSTEMS = 'assistive-listening-systems';
    const _ASTERISK = 'asterisk';
    const _AT = 'at';
    const _AUDIO_DESCRIPTION = 'audio-description';
    const _AUTOMOBILE = 'automobile';
    const _BACKWARD = 'backward';
    const _BALANCE_SCALE = 'balance-scale';
    const _BAN = 'ban';
    const _BANK = 'bank';
    const _BAR_CHART = 'bar-chart';
    const _BAR_CHART_O = 'bar-chart-o';
    const _BARCODE = 'barcode';
    const _BARS = 'bars';
    const _BATTERY_0 = 'battery-0';
    const _BATTERY_1 = 'battery-1';
    const _BATTERY_2 = 'battery-2';
    const _BATTERY_3 = 'battery-3';
    const _BATTERY_4 = 'battery-4';
    const _BATTERY_EMPTY = 'battery-empty';
    const _BATTERY_FULL = 'battery-full';
    const _BATTERY_HALF = 'battery-half';
    const _BATTERY_QUARTER = 'battery-quarter';
    const _BATTERY_THREE_QUARTERS = 'battery-three-quarters';
    const _BED = 'bed';
    const _BEER = 'beer';
    const _BEHANCE = 'behance';
    const _BEHANCE_SQUARE = 'behance-square';
    const _BELL = 'bell';
    const _BELL_O = 'bell-o';
    const _BELL_SLASH = 'bell-slash';
    const _BELL_SLASH_O = 'bell-slash-o';
    const _BICYCLE = 'bicycle';
    const _BINOCULARS = 'binoculars';
    const _BIRTHDAY_CAKE = 'birthday-cake';
    const _BITBUCKET = 'bitbucket';
    const _BITBUCKET_SQUARE = 'bitbucket-square';
    const _BITCOIN = 'bitcoin';
    const _BLACK_TIE = 'black-tie';
    const _BLIND = 'blind';
    const _BLUETOOTH = 'bluetooth';
    const _BLUETOOTH_B = 'bluetooth-b';
    const _BOLD = 'bold';
    const _BOLT = 'bolt';
    const _BOMB = 'bomb';
    const _BOOK = 'book';
    const _BOOKMARK = 'bookmark';
    const _BOOKMARK_O = 'bookmark-o';
    const _BRAILLE = 'braille';
    const _BRIEFCASE = 'briefcase';
    const _BTC = 'btc';
    const _BUG = 'bug';
    const _BUILDING = 'building';
    const _BUILDING_O = 'building-o';
    const _BULLHORN = 'bullhorn';
    const _BULLSEYE = 'bullseye';
    const _BUS = 'bus';
    const _BUYSELLADS = 'buysellads';
    const _CAB = 'cab';
    const _CALCULATOR = 'calculator';
    const _CALENDAR = 'calendar';
    const _CALENDAR_CHECK_O = 'calendar-check-o';
    const _CALENDAR_MINUS_O = 'calendar-minus-o';
    const _CALENDAR_O = 'calendar-o';
    const _CALENDAR_PLUS_O = 'calendar-plus-o';
    const _CALENDAR_TIMES_O = 'calendar-times-o';
    const _CAMERA = 'camera';
    const _CAMERA_RETRO = 'camera-retro';
    const _CAR = 'car';
    const _CARET_DOWN = 'caret-down';
    const _CARET_LEFT = 'caret-left';
    const _CARET_RIGHT = 'caret-right';
    const _CARET_SQUARE_O_DOWN = 'caret-square-o-down';
    const _CARET_SQUARE_O_LEFT = 'caret-square-o-left';
    const _CARET_SQUARE_O_RIGHT = 'caret-square-o-right';
    const _CARET_SQUARE_O_UP = 'caret-square-o-up';
    const _CARET_UP = 'caret-up';
    const _CART_ARROW_DOWN = 'cart-arrow-down';
    const _CART_PLUS = 'cart-plus';
    const _CC = 'cc';
    const _CC_AMEX = 'cc-amex';
    const _CC_DINERS_CLUB = 'cc-diners-club';
    const _CC_DISCOVER = 'cc-discover';
    const _CC_JCB = 'cc-jcb';
    const _CC_MASTERCARD = 'cc-mastercard';
    const _CC_PAYPAL = 'cc-paypal';
    const _CC_STRIPE = 'cc-stripe';
    const _CC_VISA = 'cc-visa';
    const _CERTIFICATE = 'certificate';
    const _CHAIN = 'chain';
    const _CHAIN_BROKEN = 'chain-broken';
    const _CHECK = 'check';
    const _CHECK_CIRCLE = 'check-circle';
    const _CHECK_CIRCLE_O = 'check-circle-o';
    const _CHECK_SQUARE = 'check-square';
    const _CHECK_SQUARE_O = 'check-square-o';
    const _CHEVRON_CIRCLE_DOWN = 'chevron-circle-down';
    const _CHEVRON_CIRCLE_LEFT = 'chevron-circle-left';
    const _CHEVRON_CIRCLE_RIGHT = 'chevron-circle-right';
    const _CHEVRON_CIRCLE_UP = 'chevron-circle-up';
    const _CHEVRON_DOWN = 'chevron-down';
    const _CHEVRON_LEFT = 'chevron-left';
    const _CHEVRON_RIGHT = 'chevron-right';
    const _CHEVRON_UP = 'chevron-up';
    const _CHILD = 'child';
    const _CHROME = 'chrome';
    const _CIRCLE = 'circle';
    const _CIRCLE_O = 'circle-o';
    const _CIRCLE_O_NOTCH = 'circle-o-notch';
    const _CIRCLE_THIN = 'circle-thin';
    const _CLIPBOARD = 'clipboard';
    const _CLOCK_O = 'clock-o';
    const _CLONE = 'clone';
    const _CLOSE = 'close';
    const _CLOUD = 'cloud';
    const _CLOUD_DOWNLOAD = 'cloud-download';
    const _CLOUD_UPLOAD = 'cloud-upload';
    const _CNY = 'cny';
    const _CODE = 'code';
    const _CODE_FORK = 'code-fork';
    const _CODEPEN = 'codepen';
    const _CODIEPIE = 'codiepie';
    const _COFFEE = 'coffee';
    const _COG = 'cog';
    const _COGS = 'cogs';
    const _COLUMNS = 'columns';
    const _COMMENT = 'comment';
    const _COMMENT_O = 'comment-o';
    const _COMMENTING = 'commenting';
    const _COMMENTING_O = 'commenting-o';
    const _COMMENTS = 'comments';
    const _COMMENTS_O = 'comments-o';
    const _COMPASS = 'compass';
    const _COMPRESS = 'compress';
    const _CONNECTDEVELOP = 'connectdevelop';
    const _CONTAO = 'contao';
    const _COPY = 'copy';
    const _COPYRIGHT = 'copyright';
    const _CREATIVE_COMMONS = 'creative-commons';
    const _CREDIT_CARD = 'credit-card';
    const _CREDIT_CARD_ALT = 'credit-card-alt';
    const _CROP = 'crop';
    const _CROSSHAIRS = 'crosshairs';
    const _CSS3 = 'css3';
    const _CUBE = 'cube';
    const _CUBES = 'cubes';
    const _CUT = 'cut';
    const _CUTLERY = 'cutlery';
    const _DASHBOARD = 'dashboard';
    const _DASHCUBE = 'dashcube';
    const _DATABASE = 'database';
    const _DEAF = 'deaf';
    const _DEAFNESS = 'deafness';
    const _DEDENT = 'dedent';
    const _DELICIOUS = 'delicious';
    const _DESKTOP = 'desktop';
    const _DEVIANTART = 'deviantart';
    const _DIAMOND = 'diamond';
    const _DIGG = 'digg';
    const _DOLLAR = 'dollar';
    const _DOT_CIRCLE_O = 'dot-circle-o';
    const _DOWNLOAD = 'download';
    const _DRIBBBLE = 'dribbble';
    const _DROPBOX = 'dropbox';
    const _DRUPAL = 'drupal';
    const _EDGE = 'edge';
    const _EDIT = 'edit';
    const _EJECT = 'eject';
    const _ELLIPSIS_H = 'ellipsis-h';
    const _ELLIPSIS_V = 'ellipsis-v';
    const _EMPIRE = 'empire';
    const _ENVELOPE = 'envelope';
    const _ENVELOPE_O = 'envelope-o';
    const _ENVELOPE_SQUARE = 'envelope-square';
    const _ENVIRA = 'envira';
    const _ERASER = 'eraser';
    const _EUR = 'eur';
    const _EURO = 'euro';
    const _EXCHANGE = 'exchange';
    const _EXCLAMATION = 'exclamation';
    const _EXCLAMATION_CIRCLE = 'exclamation-circle';
    const _EXCLAMATION_TRIANGLE = 'exclamation-triangle';
    const _EXPAND = 'expand';
    const _EXPEDITEDSSL = 'expeditedssl';
    const _EXTERNAL_LINK = 'external-link';
    const _EXTERNAL_LINK_SQUARE = 'external-link-square';
    const _EYE = 'eye';
    const _EYE_SLASH = 'eye-slash';
    const _EYEDROPPER = 'eyedropper';
    const _FA = 'fa';
    const _FACEBOOK = 'facebook';
    const _FACEBOOK_F = 'facebook-f';
    const _FACEBOOK_OFFICIAL = 'facebook-official';
    const _FACEBOOK_SQUARE = 'facebook-square';
    const _FAST_BACKWARD = 'fast-backward';
    const _FAST_FORWARD = 'fast-forward';
    const _FAX = 'fax';
    const _FEED = 'feed';
    const _FEMALE = 'female';
    const _FIGHTER_JET = 'fighter-jet';
    const _FILE = 'file';
    const _FILE_ARCHIVE_O = 'file-archive-o';
    const _FILE_AUDIO_O = 'file-audio-o';
    const _FILE_CODE_O = 'file-code-o';
    const _FILE_EXCEL_O = 'file-excel-o';
    const _FILE_IMAGE_O = 'file-image-o';
    const _FILE_MOVIE_O = 'file-movie-o';
    const _FILE_O = 'file-o';
    const _FILE_PDF_O = 'file-pdf-o';
    const _FILE_PHOTO_O = 'file-photo-o';
    const _FILE_PICTURE_O = 'file-picture-o';
    const _FILE_POWERPOINT_O = 'file-powerpoint-o';
    const _FILE_SOUND_O = 'file-sound-o';
    const _FILE_TEXT = 'file-text';
    const _FILE_TEXT_O = 'file-text-o';
    const _FILE_VIDEO_O = 'file-video-o';
    const _FILE_WORD_O = 'file-word-o';
    const _FILE_ZIP_O = 'file-zip-o';
    const _FILES_O = 'files-o';
    const _FILM = 'film';
    const _FILTER = 'filter';
    const _FIRE = 'fire';
    const _FIRE_EXTINGUISHER = 'fire-extinguisher';
    const _FIREFOX = 'firefox';
    const _FIRST_ORDER = 'first-order';
    const _FLAG = 'flag';
    const _FLAG_CHECKERED = 'flag-checkered';
    const _FLAG_O = 'flag-o';
    const _FLASH = 'flash';
    const _FLASK = 'flask';
    const _FLICKR = 'flickr';
    const _FLOPPY_O = 'floppy-o';
    const _FOLDER = 'folder';
    const _FOLDER_O = 'folder-o';
    const _FOLDER_OPEN = 'folder-open';
    const _FOLDER_OPEN_O = 'folder-open-o';
    const _FONT = 'font';
    const _FONT_AWESOME = 'font-awesome';
    const _FONTICONS = 'fonticons';
    const _FORT_AWESOME = 'fort-awesome';
    const _FORUMBEE = 'forumbee';
    const _FORWARD = 'forward';
    const _FOURSQUARE = 'foursquare';
    const _FROWN_O = 'frown-o';
    const _FUTBOL_O = 'futbol-o';
    const _GAMEPAD = 'gamepad';
    const _GAVEL = 'gavel';
    const _GBP = 'gbp';
    const _GE = 'ge';
    const _GEAR = 'gear';
    const _GEARS = 'gears';
    const _GENDERLESS = 'genderless';
    const _GET_POCKET = 'get-pocket';
    const _GG = 'gg';
    const _GG_CIRCLE = 'gg-circle';
    const _GIFT = 'gift';
    const _GIT = 'git';
    const _GIT_SQUARE = 'git-square';
    const _GITHUB = 'github';
    const _GITHUB_ALT = 'github-alt';
    const _GITHUB_SQUARE = 'github-square';
    const _GITLAB = 'gitlab';
    const _GITTIP = 'gittip';
    const _GLASS = 'glass';
    const _GLIDE = 'glide';
    const _GLIDE_G = 'glide-g';
    const _GLOBE = 'globe';
    const _GOOGLE = 'google';
    const _GOOGLE_PLUS = 'google-plus';
    const _GOOGLE_PLUS_CIRCLE = 'google-plus-circle';
    const _GOOGLE_PLUS_OFFICIAL = 'google-plus-official';
    const _GOOGLE_PLUS_SQUARE = 'google-plus-square';
    const _GOOGLE_WALLET = 'google-wallet';
    const _GRADUATION_CAP = 'graduation-cap';
    const _GRATIPAY = 'gratipay';
    const _GROUP = 'group';
    const _H_SQUARE = 'h-square';
    const _HACKER_NEWS = 'hacker-news';
    const _HAND_GRAB_O = 'hand-grab-o';
    const _HAND_LIZARD_O = 'hand-lizard-o';
    const _HAND_O_DOWN = 'hand-o-down';
    const _HAND_O_LEFT = 'hand-o-left';
    const _HAND_O_RIGHT = 'hand-o-right';
    const _HAND_O_UP = 'hand-o-up';
    const _HAND_PAPER_O = 'hand-paper-o';
    const _HAND_PEACE_O = 'hand-peace-o';
    const _HAND_POINTER_O = 'hand-pointer-o';
    const _HAND_ROCK_O = 'hand-rock-o';
    const _HAND_SCISSORS_O = 'hand-scissors-o';
    const _HAND_SPOCK_O = 'hand-spock-o';
    const _HAND_STOP_O = 'hand-stop-o';
    const _HARD_OF_HEARING = 'hard-of-hearing';
    const _HASHTAG = 'hashtag';
    const _HDD_O = 'hdd-o';
    const _HEADER = 'header';
    const _HEADPHONES = 'headphones';
    const _HEART = 'heart';
    const _HEART_O = 'heart-o';
    const _HEARTBEAT = 'heartbeat';
    const _HISTORY = 'history';
    const _HOME = 'home';
    const _HOSPITAL_O = 'hospital-o';
    const _HOTEL = 'hotel';
    const _HOURGLASS = 'hourglass';
    const _HOURGLASS_1 = 'hourglass-1';
    const _HOURGLASS_2 = 'hourglass-2';
    const _HOURGLASS_3 = 'hourglass-3';
    const _HOURGLASS_END = 'hourglass-end';
    const _HOURGLASS_HALF = 'hourglass-half';
    const _HOURGLASS_O = 'hourglass-o';
    const _HOURGLASS_START = 'hourglass-start';
    const _HOUZZ = 'houzz';
    const _HTML5 = 'html5';
    const _I_CURSOR = 'i-cursor';
    const _ILS = 'ils';
    const _IMAGE = 'image';
    const _INBOX = 'inbox';
    const _INDENT = 'indent';
    const _INDUSTRY = 'industry';
    const _INFO = 'info';
    const _INFO_CIRCLE = 'info-circle';
    const _INR = 'inr';
    const _INSTAGRAM = 'instagram';
    const _INSTITUTION = 'institution';
    const _INTERNET_EXPLORER = 'internet-explorer';
    const _INTERSEX = 'intersex';
    const _IOXHOST = 'ioxhost';
    const _ITALIC = 'italic';
    const _JOOMLA = 'joomla';
    const _JPY = 'jpy';
    const _JSFIDDLE = 'jsfiddle';
    const _KEY = 'key';
    const _KEYBOARD_O = 'keyboard-o';
    const _KRW = 'krw';
    const _LANGUAGE = 'language';
    const _LAPTOP = 'laptop';
    const _LASTFM = 'lastfm';
    const _LASTFM_SQUARE = 'lastfm-square';
    const _LEAF = 'leaf';
    const _LEANPUB = 'leanpub';
    const _LEGAL = 'legal';
    const _LEMON_O = 'lemon-o';
    const _LEVEL_DOWN = 'level-down';
    const _LEVEL_UP = 'level-up';
    const _LIFE_BOUY = 'life-bouy';
    const _LIFE_BUOY = 'life-buoy';
    const _LIFE_RING = 'life-ring';
    const _LIFE_SAVER = 'life-saver';
    const _LIGHTBULB_O = 'lightbulb-o';
    const _LINE_CHART = 'line-chart';
    const _LINK = 'link';
    const _LINKEDIN = 'linkedin';
    const _LINKEDIN_SQUARE = 'linkedin-square';
    const _LINUX = 'linux';
    const _LIST = 'list';
    const _LIST_ALT = 'list-alt';
    const _LIST_OL = 'list-ol';
    const _LIST_UL = 'list-ul';
    const _LOCATION_ARROW = 'location-arrow';
    const _LOCK = 'lock';
    const _LONG_ARROW_DOWN = 'long-arrow-down';
    const _LONG_ARROW_LEFT = 'long-arrow-left';
    const _LONG_ARROW_RIGHT = 'long-arrow-right';
    const _LONG_ARROW_UP = 'long-arrow-up';
    const _LOW_VISION = 'low-vision';
    const _MAGIC = 'magic';
    const _MAGNET = 'magnet';
    const _MAIL_FORWARD = 'mail-forward';
    const _MAIL_REPLY = 'mail-reply';
    const _MAIL_REPLY_ALL = 'mail-reply-all';
    const _MALE = 'male';
    const _MAP = 'map';
    const _MAP_MARKER = 'map-marker';
    const _MAP_O = 'map-o';
    const _MAP_PIN = 'map-pin';
    const _MAP_SIGNS = 'map-signs';
    const _MARS = 'mars';
    const _MARS_DOUBLE = 'mars-double';
    const _MARS_STROKE = 'mars-stroke';
    const _MARS_STROKE_H = 'mars-stroke-h';
    const _MARS_STROKE_V = 'mars-stroke-v';
    const _MAXCDN = 'maxcdn';
    const _MEANPATH = 'meanpath';
    const _MEDIUM = 'medium';
    const _MEDKIT = 'medkit';
    const _MEH_O = 'meh-o';
    const _MERCURY = 'mercury';
    const _MICROPHONE = 'microphone';
    const _MICROPHONE_SLASH = 'microphone-slash';
    const _MINUS = 'minus';
    const _MINUS_CIRCLE = 'minus-circle';
    const _MINUS_SQUARE = 'minus-square';
    const _MINUS_SQUARE_O = 'minus-square-o';
    const _MIXCLOUD = 'mixcloud';
    const _MOBILE = 'mobile';
    const _MOBILE_PHONE = 'mobile-phone';
    const _MODX = 'modx';
    const _MONEY = 'money';
    const _MOON_O = 'moon-o';
    const _MORTAR_BOARD = 'mortar-board';
    const _MOTORCYCLE = 'motorcycle';
    const _MOUSE_POINTER = 'mouse-pointer';
    const _MUSIC = 'music';
    const _NAVICON = 'navicon';
    const _NEUTER = 'neuter';
    const _NEWSPAPER_O = 'newspaper-o';
    const _OBJECT_GROUP = 'object-group';
    const _OBJECT_UNGROUP = 'object-ungroup';
    const _ODNOKLASSNIKI = 'odnoklassniki';
    const _ODNOKLASSNIKI_SQUARE = 'odnoklassniki-square';
    const _OPENCART = 'opencart';
    const _OPENID = 'openid';
    const _OPERA = 'opera';
    const _OPTIN_MONSTER = 'optin-monster';
    const _OUTDENT = 'outdent';
    const _PAGELINES = 'pagelines';
    const _PAINT_BRUSH = 'paint-brush';
    const _PAPER_PLANE = 'paper-plane';
    const _PAPER_PLANE_O = 'paper-plane-o';
    const _PAPERCLIP = 'paperclip';
    const _PARAGRAPH = 'paragraph';
    const _PASTE = 'paste';
    const _PAUSE = 'pause';
    const _PAUSE_CIRCLE = 'pause-circle';
    const _PAUSE_CIRCLE_O = 'pause-circle-o';
    const _PAW = 'paw';
    const _PAYPAL = 'paypal';
    const _PENCIL = 'pencil';
    const _PENCIL_SQUARE = 'pencil-square';
    const _PENCIL_SQUARE_O = 'pencil-square-o';
    const _PERCENT = 'percent';
    const _PHONE = 'phone';
    const _PHONE_SQUARE = 'phone-square';
    const _PHOTO = 'photo';
    const _PICTURE_O = 'picture-o';
    const _PIE_CHART = 'pie-chart';
    const _PIED_PIPER = 'pied-piper';
    const _PIED_PIPER_ALT = 'pied-piper-alt';
    const _PIED_PIPER_PP = 'pied-piper-pp';
    const _PINTEREST = 'pinterest';
    const _PINTEREST_P = 'pinterest-p';
    const _PINTEREST_SQUARE = 'pinterest-square';
    const _PLANE = 'plane';
    const _PLAY = 'play';
    const _PLAY_CIRCLE = 'play-circle';
    const _PLAY_CIRCLE_O = 'play-circle-o';
    const _PLUG = 'plug';
    const _PLUS = 'plus';
    const _PLUS_CIRCLE = 'plus-circle';
    const _PLUS_SQUARE = 'plus-square';
    const _PLUS_SQUARE_O = 'plus-square-o';
    const _POWER_OFF = 'power-off';
    const _PRINT = 'print';
    const _PRODUCT_HUNT = 'product-hunt';
    const _PUZZLE_PIECE = 'puzzle-piece';
    const _QQ = 'qq';
    const _QRCODE = 'qrcode';
    const _QUESTION = 'question';
    const _QUESTION_CIRCLE = 'question-circle';
    const _QUESTION_CIRCLE_O = 'question-circle-o';
    const _QUOTE_LEFT = 'quote-left';
    const _QUOTE_RIGHT = 'quote-right';
    const _RA = 'ra';
    const _RANDOM = 'random';
    const _REBEL = 'rebel';
    const _RECYCLE = 'recycle';
    const _REDDIT = 'reddit';
    const _REDDIT_ALIEN = 'reddit-alien';
    const _REDDIT_SQUARE = 'reddit-square';
    const _REFRESH = 'refresh';
    const _REGISTERED = 'registered';
    const _REMOVE = 'remove';
    const _RENREN = 'renren';
    const _REORDER = 'reorder';
    const _REPEAT = 'repeat';
    const _REPLY = 'reply';
    const _REPLY_ALL = 'reply-all';
    const _RESISTANCE = 'resistance';
    const _RETWEET = 'retweet';
    const _RMB = 'rmb';
    const _ROAD = 'road';
    const _ROCKET = 'rocket';
    const _ROTATE_LEFT = 'rotate-left';
    const _ROTATE_RIGHT = 'rotate-right';
    const _ROUBLE = 'rouble';
    const _RSS = 'rss';
    const _RSS_SQUARE = 'rss-square';
    const _RUB = 'rub';
    const _RUBLE = 'ruble';
    const _RUPEE = 'rupee';
    const _SAFARI = 'safari';
    const _SAVE = 'save';
    const _SCISSORS = 'scissors';
    const _SCRIBD = 'scribd';
    const _SEARCH = 'search';
    const _SEARCH_MINUS = 'search-minus';
    const _SEARCH_PLUS = 'search-plus';
    const _SELLSY = 'sellsy';
    const _SEND = 'send';
    const _SEND_O = 'send-o';
    const _SERVER = 'server';
    const _SHARE = 'share';
    const _SHARE_ALT = 'share-alt';
    const _SHARE_ALT_SQUARE = 'share-alt-square';
    const _SHARE_SQUARE = 'share-square';
    const _SHARE_SQUARE_O = 'share-square-o';
    const _SHEKEL = 'shekel';
    const _SHEQEL = 'sheqel';
    const _SHIELD = 'shield';
    const _SHIP = 'ship';
    const _SHIRTSINBULK = 'shirtsinbulk';
    const _SHOPPING_BAG = 'shopping-bag';
    const _SHOPPING_BASKET = 'shopping-basket';
    const _SHOPPING_CART = 'shopping-cart';
    const _SIGN_IN = 'sign-in';
    const _SIGN_LANGUAGE = 'sign-language';
    const _SIGN_OUT = 'sign-out';
    const _SIGNAL = 'signal';
    const _SIGNING = 'signing';
    const _SIMPLYBUILT = 'simplybuilt';
    const _SITEMAP = 'sitemap';
    const _SKYATLAS = 'skyatlas';
    const _SKYPE = 'skype';
    const _SLACK = 'slack';
    const _SLIDERS = 'sliders';
    const _SLIDESHARE = 'slideshare';
    const _SMILE_O = 'smile-o';
    const _SNAPCHAT = 'snapchat';
    const _SNAPCHAT_GHOST = 'snapchat-ghost';
    const _SNAPCHAT_SQUARE = 'snapchat-square';
    const _SOCCER_BALL_O = 'soccer-ball-o';
    const _SORT = 'sort';
    const _SORT_ALPHA_ASC = 'sort-alpha-asc';
    const _SORT_ALPHA_DESC = 'sort-alpha-desc';
    const _SORT_AMOUNT_ASC = 'sort-amount-asc';
    const _SORT_AMOUNT_DESC = 'sort-amount-desc';
    const _SORT_ASC = 'sort-asc';
    const _SORT_DESC = 'sort-desc';
    const _SORT_DOWN = 'sort-down';
    const _SORT_NUMERIC_ASC = 'sort-numeric-asc';
    const _SORT_NUMERIC_DESC = 'sort-numeric-desc';
    const _SORT_UP = 'sort-up';
    const _SOUNDCLOUD = 'soundcloud';
    const _SPACE_SHUTTLE = 'space-shuttle';
    const _SPINNER = 'spinner';
    const _SPOON = 'spoon';
    const _SPOTIFY = 'spotify';
    const _SQUARE = 'square';
    const _SQUARE_O = 'square-o';
    const _STACK_EXCHANGE = 'stack-exchange';
    const _STACK_OVERFLOW = 'stack-overflow';
    const _STAR = 'star';
    const _STAR_HALF = 'star-half';
    const _STAR_HALF_EMPTY = 'star-half-empty';
    const _STAR_HALF_FULL = 'star-half-full';
    const _STAR_HALF_O = 'star-half-o';
    const _STAR_O = 'star-o';
    const _STEAM = 'steam';
    const _STEAM_SQUARE = 'steam-square';
    const _STEP_BACKWARD = 'step-backward';
    const _STEP_FORWARD = 'step-forward';
    const _STETHOSCOPE = 'stethoscope';
    const _STICKY_NOTE = 'sticky-note';
    const _STICKY_NOTE_O = 'sticky-note-o';
    const _STOP = 'stop';
    const _STOP_CIRCLE = 'stop-circle';
    const _STOP_CIRCLE_O = 'stop-circle-o';
    const _STREET_VIEW = 'street-view';
    const _STRIKETHROUGH = 'strikethrough';
    const _STUMBLEUPON = 'stumbleupon';
    const _STUMBLEUPON_CIRCLE = 'stumbleupon-circle';
    const _SUBSCRIPT = 'subscript';
    const _SUBWAY = 'subway';
    const _SUITCASE = 'suitcase';
    const _SUN_O = 'sun-o';
    const _SUPERSCRIPT = 'superscript';
    const _SUPPORT = 'support';
    const _TABLE = 'table';
    const _TABLET = 'tablet';
    const _TACHOMETER = 'tachometer';
    const _TAG = 'tag';
    const _TAGS = 'tags';
    const _TASKS = 'tasks';
    const _TAXI = 'taxi';
    const _TELEVISION = 'television';
    const _TENCENT_WEIBO = 'tencent-weibo';
    const _TERMINAL = 'terminal';
    const _TEXT_HEIGHT = 'text-height';
    const _TEXT_WIDTH = 'text-width';
    const _TH = 'th';
    const _TH_LARGE = 'th-large';
    const _TH_LIST = 'th-list';
    const _THEMEISLE = 'themeisle';
    const _THUMB_TACK = 'thumb-tack';
    const _THUMBS_DOWN = 'thumbs-down';
    const _THUMBS_O_DOWN = 'thumbs-o-down';
    const _THUMBS_O_UP = 'thumbs-o-up';
    const _THUMBS_UP = 'thumbs-up';
    const _TICKET = 'ticket';
    const _TIMES = 'times';
    const _TIMES_CIRCLE = 'times-circle';
    const _TIMES_CIRCLE_O = 'times-circle-o';
    const _TINT = 'tint';
    const _TOGGLE_DOWN = 'toggle-down';
    const _TOGGLE_LEFT = 'toggle-left';
    const _TOGGLE_OFF = 'toggle-off';
    const _TOGGLE_ON = 'toggle-on';
    const _TOGGLE_RIGHT = 'toggle-right';
    const _TOGGLE_UP = 'toggle-up';
    const _TRADEMARK = 'trademark';
    const _TRAIN = 'train';
    const _TRANSGENDER = 'transgender';
    const _TRANSGENDER_ALT = 'transgender-alt';
    const _TRASH = 'trash';
    const _TRASH_O = 'trash-o';
    const _TREE = 'tree';
    const _TRELLO = 'trello';
    const _TRIPADVISOR = 'tripadvisor';
    const _TROPHY = 'trophy';
    const _TRUCK = 'truck';
    const _TRY = 'try';
    const _TTY = 'tty';
    const _TUMBLR = 'tumblr';
    const _TUMBLR_SQUARE = 'tumblr-square';
    const _TURKISH_LIRA = 'turkish-lira';
    const _TV = 'tv';
    const _TWITCH = 'twitch';
    const _TWITTER = 'twitter';
    const _TWITTER_SQUARE = 'twitter-square';
    const _UMBRELLA = 'umbrella';
    const _UNDERLINE = 'underline';
    const _UNDO = 'undo';
    const _UNIVERSAL_ACCESS = 'universal-access';
    const _UNIVERSITY = 'university';
    const _UNLINK = 'unlink';
    const _UNLOCK = 'unlock';
    const _UNLOCK_ALT = 'unlock-alt';
    const _UNSORTED = 'unsorted';
    const _UPLOAD = 'upload';
    const _USB = 'usb';
    const _USD = 'usd';
    const _USER = 'user';
    const _USER_MD = 'user-md';
    const _USER_PLUS = 'user-plus';
    const _USER_SECRET = 'user-secret';
    const _USER_TIMES = 'user-times';
    const _USERS = 'users';
    const _VENUS = 'venus';
    const _VENUS_DOUBLE = 'venus-double';
    const _VENUS_MARS = 'venus-mars';
    const _VIACOIN = 'viacoin';
    const _VIADEO = 'viadeo';
    const _VIADEO_SQUARE = 'viadeo-square';
    const _VIDEO_CAMERA = 'video-camera';
    const _VIMEO = 'vimeo';
    const _VIMEO_SQUARE = 'vimeo-square';
    const _VINE = 'vine';
    const _VK = 'vk';
    const _VOLUME_CONTROL_PHONE = 'volume-control-phone';
    const _VOLUME_DOWN = 'volume-down';
    const _VOLUME_OFF = 'volume-off';
    const _VOLUME_UP = 'volume-up';
    const _WARNING = 'warning';
    const _WECHAT = 'wechat';
    const _WEIBO = 'weibo';
    const _WEIXIN = 'weixin';
    const _WHATSAPP = 'whatsapp';
    const _WHEELCHAIR = 'wheelchair';
    const _WHEELCHAIR_ALT = 'wheelchair-alt';
    const _WIFI = 'wifi';
    const _WIKIPEDIA_W = 'wikipedia-w';
    const _WINDOWS = 'windows';
    const _WON = 'won';
    const _WORDPRESS = 'wordpress';
    const _WPBEGINNER = 'wpbeginner';
    const _WPFORMS = 'wpforms';
    const _WRENCH = 'wrench';
    const _XING = 'xing';
    const _XING_SQUARE = 'xing-square';
    const _Y_COMBINATOR = 'y-combinator';
    const _Y_COMBINATOR_SQUARE = 'y-combinator-square';
    const _YAHOO = 'yahoo';
    const _YC = 'yc';
    const _YC_SQUARE = 'yc-square';
    const _YELP = 'yelp';
    const _YEN = 'yen';
    const _YOAST = 'yoast';
    const _YOUTUBE = 'youtube';
    const _YOUTUBE_PLAY = 'youtube-play';
    const _YOUTUBE_SQUARE = 'youtube-square';
}