text:
using System.Diagnostics;

using SafeWinHttpHandle = Interop.WinHttp.SafeWinHttpHandle;

namespace System.Net.Http
{
    internal class WinHttpAuthHelper
    {
        // TODO: Issue #2165. This looks messy but it is fast. Research a cleaner way
        // to do this which keeps high performance lookup.
        //
        // Fast lookup table to convert WINHTTP_AUTH constants to strings.
        // WINHTTP_AUTH_SCHEME_BASIC = 0x00000001;
        // WINHTTP_AUTH_SCHEME_NTLM = 0x00000002;
        // WINHTTP_AUTH_SCHEME_DIGEST = 0x00000008;
        // WINHTTP_AUTH_SCHEME_NEGOTIATE = 0x00000010;
        private static readonly string[] s_authSchemeStringMapping =
        {
            null,
            "Basic",
            "NTLM",
            null,
            null,
            null,
            null,
            null,
            "Digest",
            null,
            null,
            null,
            null,
            null,
            null,
            null,
            "Negotiate"
        };

        private static readonly uint[] s_authSchemePriorityOrder =
        {
            Interop.WinHttp.WINHTTP_AUTH_SCHEME_NEGOTIATE,
            Interop.WinHttp.WINHTTP_AUTH_SCHEME_NTLM,
            Interop.WinHttp.WINHTTP_AUTH_SCHEME_DIGEST,
            Interop.WinHttp.WINHTTP_AUTH_SCHEME_BASIC
        };

        // TODO: Issue #2165. This current design uses a handler-wide lock to Add/Retrieve
        // from the cache.  Need to improve this for next iteration in order
        // to boost performance and scalability.
        private readonly CredentialCache _credentialCache = new CredentialCache();
        private readonly object _credentialCacheLock = new object();

        public void CheckResponseForAuthentication(
            WinHttpRequestState state,
            ref uint proxyAuthScheme,
            ref uint serverAuthScheme)
        {
            uint supportedSchemes = 0;
            uint firstSchemeIgnored = 0;
            uint authTarget = 0;
            Uri uri = state.RequestMessage.RequestUri;

            state.RetryRequest = false;

            // Check the status code and retry the request applying credentials if needed.
            var statusCode = (HttpStatusCode)WinHttpResponseParser.GetResponseHeaderNumberInfo(
                state.RequestHandle,
                Interop.WinHttp.WINHTTP_QUERY_STATUS_CODE);

            switch (statusCode)
            {
                case HttpStatusCode.Unauthorized:
                    if (state.ServerCredentials == null || state.LastStatusCode == HttpStatusCode.Unauthorized)
                    {
                        // Either we don't have server credentials or we already tried
                        // to set the credentials and it failed before.
                        // So we will let the 401 be the final status code returned.
                        break;
                    }

                    state.LastStatusCode = statusCode;

                    // Determine authorization scheme to use. We ignore the firstScheme
                    // parameter which is included in the supportedSchemes flags already.
                    // We pass the schemes to ChooseAuthScheme which will pick the scheme
                    // based on most secure scheme to least secure scheme ordering.
                    if (!Interop.WinHttp.WinHttpQueryAuthSchemes(
                        state.RequestHandle,
                        out supportedSchemes,
                        out firstSchemeIgnored,
                        out authTarget))
                    {
                        WinHttpException.ThrowExceptionUsingLastError();
                    }

                    // WinHTTP returns the proper authTarget based on the status code (401, 407).
                    // But we can validate with assert.
                    Debug.Assert(authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_SERVER);

                    serverAuthScheme = ChooseAuthScheme(supportedSchemes);
                    if (serverAuthScheme != 0)
                    {
                        SetWinHttpCredential(
                            state.RequestHandle,
                            state.ServerCredentials,
                            uri,
                            serverAuthScheme,
                            authTarget);

                        state.RetryRequest = true;
                    }

                    break;

                case HttpStatusCode.ProxyAuthenticationRequired:
                    if (state.LastStatusCode == HttpStatusCode.ProxyAuthenticationRequired)
                    {
                        // We tried already to set the credentials.
                        break;
                    }

                    state.LastStatusCode = statusCode;

                    // If we don't have any proxy credentials to try, then we end up with 407.
                    ICredentials proxyCreds = state.Proxy == null ?
                        state.DefaultProxyCredentials :
                        state.Proxy.Credentials;
                     if (proxyCreds == null)
                     {
                         break;
                     }

                    // Determine authorization scheme to use. We ignore the firstScheme
                    // parameter which is included in the supportedSchemes flags already.
                    // We pass the schemes to ChooseAuthScheme which will pick the scheme
                    // based on most secure scheme to least secure scheme ordering.
                    if (!Interop.WinHttp.WinHttpQueryAuthSchemes(
                        state.RequestHandle,
                        out supportedSchemes,
                        out firstSchemeIgnored,
                        out authTarget))
                    {
                        WinHttpException.ThrowExceptionUsingLastError();
                    }

                    // WinHTTP returns the proper authTarget based on the status code (401, 407).
                    // But we can validate with assert.
                    Debug.Assert(authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_PROXY);

                    proxyAuthScheme = ChooseAuthScheme(supportedSchemes);
                    state.RetryRequest = true;
                    break;

                default:
                    if (state.PreAuthenticate && serverAuthScheme != 0)
                    {
                        SaveServerCredentialsToCache(uri, serverAuthScheme, state.ServerCredentials);
                    }
                    break;
            }
        }

        public void PreAuthenticateRequest(WinHttpRequestState state, uint proxyAuthScheme)
        {
            // Set proxy credentials if we have them.
            // If a proxy authentication challenge was responded to, reset
            // those credentials before each SendRequest, because the proxy
            // may require re-authentication after responding to a 401 or
            // to a redirect. If you don't, you can get into a
            // 407-401-407-401- loop.
            if (proxyAuthScheme != 0)
            {
                ICredentials proxyCredentials;
                Uri proxyUri;
                if (state.Proxy != null)
                {
                    proxyCredentials = state.Proxy.Credentials;
                    proxyUri = state.Proxy.GetProxy(state.RequestMessage.RequestUri);
                }
                else
                {
                    proxyCredentials = state.DefaultProxyCredentials;
                    proxyUri = state.RequestMessage.RequestUri;
                }

                SetWinHttpCredential(
                    state.RequestHandle,
                    proxyCredentials,
                    proxyUri,
                    proxyAuthScheme,
                    Interop.WinHttp.WINHTTP_AUTH_TARGET_PROXY);
            }

            // Apply pre-authentication headers for server authentication?
            if (state.PreAuthenticate)
            {
                uint authScheme;
                NetworkCredential serverCredentials;
                if (GetServerCredentialsFromCache(
                        state.RequestMessage.RequestUri,
                        out authScheme,
                        out serverCredentials))
                {
                    SetWinHttpCredential(
                        state.RequestHandle,
                        serverCredentials,
                        state.RequestMessage.RequestUri,
                        authScheme,
                        Interop.WinHttp.WINHTTP_AUTH_TARGET_SERVER);
                    state.LastStatusCode = HttpStatusCode.Unauthorized; // Remember we already set the creds.
                }

                // No cached credential to use at this time. The request will first go out with no
                // 'Authorization' header. Later, if a 401 occurs, we will be able to cache the credential
                // since we will then know the proper auth scheme to use.
                //
                // TODO: Issue #2165. Adding logging to highlight the 'cache miss'.
            }
        }

        // TODO: Issue #2165. Consider refactoring cache logic in separate class and avoid out parameters.
        public bool GetServerCredentialsFromCache(
            Uri uri,
            out uint serverAuthScheme,
            out NetworkCredential serverCredentials)
        {
            serverAuthScheme = 0;
            serverCredentials = null;

            NetworkCredential cred = null;

            lock (_credentialCacheLock)
            {
                foreach (uint authScheme in s_authSchemePriorityOrder)
                {
                    cred = _credentialCache.GetCredential(uri, s_authSchemeStringMapping[authScheme]);
                    if (cred != null)
                    {
                        serverAuthScheme = authScheme;
                        serverCredentials = cred;

                        return true;
                    }
                }
            }

            return false;
        }

        public void SaveServerCredentialsToCache(Uri uri, uint authScheme, ICredentials serverCredentials)
        {
            string authType = s_authSchemeStringMapping[authScheme];
            Debug.Assert(!string.IsNullOrEmpty(authType));

            NetworkCredential cred = serverCredentials.GetCredential(uri, authType);
            if (cred != null)
            {
                lock (_credentialCacheLock)
                {
                    try
                    {
                        _credentialCache.Add(uri, authType, cred);
                    }
                    catch (ArgumentException)
                    {
                        // The credential was already added.
                    }
                }
            }
        }

        public void ChangeDefaultCredentialsPolicy(
            SafeWinHttpHandle requestHandle,
            uint authTarget,
            bool allowDefaultCredentials)
        {
            Debug.Assert(authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_PROXY ||
                         authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_SERVER);

            uint optionData = allowDefaultCredentials ?
                (authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_PROXY ?
                    Interop.WinHttp.WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM :
                    Interop.WinHttp.WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW) :
                Interop.WinHttp.WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH;

            if (!Interop.WinHttp.WinHttpSetOption(
                requestHandle,
                Interop.WinHttp.WINHTTP_OPTION_AUTOLOGON_POLICY,
                ref optionData))
            {
                WinHttpException.ThrowExceptionUsingLastError();
            }
        }

        private void SetWinHttpCredential(
            SafeWinHttpHandle requestHandle,
            ICredentials credentials,
            Uri uri,
            uint authScheme,
            uint authTarget)
        {
            string userName;
            string password;

            Debug.Assert(credentials != null);
            Debug.Assert(authScheme != 0);
            Debug.Assert(authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_PROXY ||
                         authTarget == Interop.WinHttp.WINHTTP_AUTH_TARGET_SERVER);

            NetworkCredential networkCredential = credentials.GetCredential(uri, s_authSchemeStringMapping[authScheme]);

            if (networkCredential == null)
            {
                return;
            }

            if (networkCredential == CredentialCache.DefaultNetworkCredentials)
            {
                // Allow WinHTTP to transmit the default credentials.
                ChangeDefaultCredentialsPolicy(requestHandle, authTarget, allowDefaultCredentials:true);
                userName = null;
                password = null;
            }
            else
            {
                userName = networkCredential.UserName;
                password = networkCredential.Password;
                string domain = networkCredential.Domain;

                // WinHTTP does not support a blank username.  So, we will throw an exception.
                if (string.IsNullOrEmpty(userName))
                {
                    throw new InvalidOperationException(SR.net_http_username_empty_string);
                }

                if (!string.IsNullOrEmpty(domain))
                {
                    userName = domain + "\\" + userName;
                }
            }

            if (!Interop.WinHttp.WinHttpSetCredentials(
                requestHandle,
                authTarget,
                authScheme,
                userName,
                password,
                IntPtr.Zero))
            {
                WinHttpException.ThrowExceptionUsingLastError();
            }
        }

        private static uint ChooseAuthScheme(uint supportedSchemes)
        {
            foreach (uint authScheme in s_authSchemePriorityOrder)
            {
                if ((supportedSchemes & authScheme) != 0)
                {
                    return authScheme;
                }
            }

            return 0;
        }
    }
}


text:
pub enum KeySize {
    /// Uses 128 bit AES key
    KeySize128 = 0x0,
    /// Uses 192 bit AES key
    KeySize192 = 0x2,
    /// Uses 256 bit AES key
    KeySize256 = 0x4,
}

#[derive(Debug, Copy, Clone)]
pub enum CipherMode {
    /// Electronic Codebook mode.
    Ecb = 0x0,
    /// Counter mode.
    Ctr = 0x8,
    /// Cypher Block Chaining mode.
    Cbc = 0x10,
    /// Galois/Counter mode.
    Gcm = 0x18,
}

#[derive(Debug, Copy, Clone)]
pub enum Mode {
    /// Input data should be decrypted.
    Decrypt = 0x0,
    /// Input data should be encrypted.
    Encrypt = 0x20,
}

#[derive(Debug, Copy, Clone)]
pub enum CtrEndian {
    /// Counter should be treated as big endian (matches NIST spec).
    Big = 0x0,
    /// Counter should be treated as little endian.
    Little = 0x40,
}

pub enum AesModule {
    Reset = 0x1,
    Enable = 0x80,
}

#[derive(Debug, Clone, Copy)]
pub enum Interrupt {
    WFIFOOverflow = 0,
    RFIFOOverflow,
    RFIFOUnderflow,
    DoneCipher,
    DoneKeyExpansion,
    DoneWipeSecrets,
}

pub enum ParsedInterrupt {
    Found(Interrupt),
    None,
}

impl From<u32> for ParsedInterrupt {
    fn from(interrupt: u32) -> Self {
        match interrupt {
            104 => ParsedInterrupt::Found(Interrupt::DoneCipher),
            105 => ParsedInterrupt::Found(Interrupt::DoneKeyExpansion),
            106 => ParsedInterrupt::Found(Interrupt::DoneWipeSecrets),
            107 => ParsedInterrupt::Found(Interrupt::RFIFOOverflow),
            108 => ParsedInterrupt::Found(Interrupt::RFIFOUnderflow),
            109 => ParsedInterrupt::Found(Interrupt::WFIFOOverflow),
            _ => ParsedInterrupt::None,
        }
    }
}

pub trait AesClient {
    fn done_cipher(&self);
    fn done_key_expansion(&self);
    fn done_wipe_secrets(&self);
}

redpajama_set_name: RedPajamaGithub


text:
package com.github.vvv1559.algorithms.leetcode.strings;

/*
 * Original text: https://leetcode.com/problems/valid-palindrome/description/
 *
 * Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
 * For example,
 *
 * "A man, a plan, a canal: Panama" is a palindrome.
 * "race a car" is not a palindrome.
 *
 * Note:
 * Have you consider that the string might be empty? This is a good question to ask during an interview.
 * For the purpose of this problem, we define empty string as valid palindrome.
 * */

import com.github.vvv1559.algorithms.annotations.Difficulty;
import com.github.vvv1559.algorithms.annotations.Level;

@Difficulty(Level.EASY)
class IsPalindrome {

    boolean isPalindrome(String s) {
        int start = 0;
        int end = s.length() - 1;
        while (start < end) {
            char startChar = Character.toLowerCase(s.charAt(start));
            char endChar = Character.toLowerCase(s.charAt(end));

            if (!Character.isLetter(startChar) && !Character.isDigit(startChar)) {
                start++;
            } else if (!Character.isLetter(endChar) && !Character.isDigit(endChar)) {
                end--;
            } else if (startChar != endChar) {
                return false;
            } else {
                start++;
                end--;
            }
        }

        return true;
    }
}


text:
import sys, regionfile, os

import BonnLogger
__bonn_logger_id__ = BonnLogger.addCommand('maskAutotracker.py',
                                           sys.argv[1:])

#########################

__cvs__id__ = "$Id: maskAutotracker.py,v 1.3 2008-07-09 01:22:15 dapple Exp $"

#########################

usage =   \
'''maskAutotracker.py path/to/date_filter dir
     eg maskAutotracker.py /path/to/2003-09-25_W-J-V SCIENCE
'''

#########################

if len(sys.argv) != 3:
    print usage
    BonnLogger.updateStatus(__bonn_logger_id__, 1)
    sys.exit(1)

maindir = sys.argv[1]
dir = sys.argv[2]

maskListFilename = '%s/autotracker_mask' % maindir
regDir = '%s/%s/reg' % (maindir, dir)

autotrackerMask = regionfile.Polygon([-1,3650,2010,3650,2010,4081,-1,4081])

if not os.path.exists(maskListFilename):
    print 'Nothing to do.'
    BonnLogger.updateStatus(__bonn_logger_id__, 0)
    sys.exit(0)

input = open(maskListFilename)
for image in input:
    image = image.strip()
    regFilename = '%s/%s.reg' % (regDir, image)

    regionfile.writeRegionFile(regFilename, [autotrackerMask])

input.close()

BonnLogger.updateStatus(__bonn_logger_id__, 0)


text:
package wrightstuff.wowscrubber.model.item;

import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

import java.util.List;

public class Item {

    @SerializedName("id")
    @Expose
    private Integer id;
    @SerializedName("disenchantingSkillRank")
    @Expose
    private Integer disenchantingSkillRank;
    @SerializedName("description")
    @Expose
    private String description;
    @SerializedName("name")
    @Expose
    private String name;
    @SerializedName("icon")
    @Expose
    private String icon;
    @SerializedName("stackable")
    @Expose
    private Integer stackable;
    @SerializedName("itemBind")
    @Expose
    private Integer itemBind;
    @SerializedName("bonusStats")
    @Expose
    private List<BonusStat> bonusStats = null;
    @SerializedName("itemSpells")
    @Expose
    private List<Object> itemSpells = null;
    @SerializedName("buyPrice")
    @Expose
    private Integer buyPrice;
    @SerializedName("itemClass")
    @Expose
    private Integer itemClass;
    @SerializedName("itemSubClass")
    @Expose
    private Integer itemSubClass;
    @SerializedName("containerSlots")
    @Expose
    private Integer containerSlots;
    @SerializedName("inventoryType")
    @Expose
    private Integer inventoryType;
    @SerializedName("equippable")
    @Expose
    private Boolean equippable;
    @SerializedName("itemLevel")
    @Expose
    private Integer itemLevel;
    @SerializedName("maxCount")
    @Expose
    private Integer maxCount;
    @SerializedName("maxDurability")
    @Expose
    private Integer maxDurability;
    @SerializedName("minFactionId")
    @Expose
    private Integer minFactionId;
    @SerializedName("minReputation")
    @Expose
    private Integer minReputation;
    @SerializedName("quality")
    @Expose
    private Integer quality;
    @SerializedName("sellPrice")
    @Expose
    private Integer sellPrice;
    @SerializedName("requiredSkill")
    @Expose
    private Integer requiredSkill;
    @SerializedName("requiredLevel")
    @Expose
    private Integer requiredLevel;
    @SerializedName("requiredSkillRank")
    @Expose
    private Integer requiredSkillRank;
    @SerializedName("itemSource")
    @Expose
    private ItemSource itemSource;
    @SerializedName("baseArmor")
    @Expose
    private Integer baseArmor;
    @SerializedName("hasSockets")
    @Expose
    private Boolean hasSockets;
    @SerializedName("isAuctionable")
    @Expose
    private Boolean isAuctionable;
    @SerializedName("armor")
    @Expose
    private Integer armor;
    @SerializedName("displayInfoId")
    @Expose
    private Integer displayInfoId;
    @SerializedName("nameDescription")
    @Expose
    private String nameDescription;
    @SerializedName("nameDescriptionColor")
    @Expose
    private String nameDescriptionColor;
    @SerializedName("upgradable")
    @Expose
    private Boolean upgradable;
    @SerializedName("heroicTooltip")
    @Expose
    private Boolean heroicTooltip;
    @SerializedName("context")
    @Expose
    private String context;
    @SerializedName("bonusLists")
    @Expose
    private List<Integer> bonusLists = null;
    @SerializedName("availableContexts")
    @Expose
    private List<String> availableContexts = null;
    @SerializedName("bonusSummary")
    @Expose
    private BonusSummary bonusSummary;
    @SerializedName("artifactId")
    @Expose
    private Integer artifactId;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getDisenchantingSkillRank() {
        return disenchantingSkillRank;
    }

    public void setDisenchantingSkillRank(Integer disenchantingSkillRank) {
        this.disenchantingSkillRank = disenchantingSkillRank;
    }

    public String getDescription() {
        return description;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIcon() {
        return icon;
    }

    public void setIcon(String icon) {
        this.icon = icon;
    }

    public Integer getStackable() {
        return stackable;
    }

    public void setStackable(Integer stackable) {
        this.stackable = stackable;
    }

    public Integer getItemBind() {
        return itemBind;
    }

    public void setItemBind(Integer itemBind) {
        this.itemBind = itemBind;
    }

    public List<BonusStat> getBonusStats() {
        return bonusStats;
    }

    public void setBonusStats(List<BonusStat> bonusStats) {
        this.bonusStats = bonusStats;
    }

    public List<Object> getItemSpells() {
        return itemSpells;
    }

    public void setItemSpells(List<Object> itemSpells) {
        this.itemSpells = itemSpells;
    }

    public Integer getBuyPrice() {
        return buyPrice;
    }

    public void setBuyPrice(Integer buyPrice) {
        this.buyPrice = buyPrice;
    }

    public Integer getItemClass() {
        return itemClass;
    }

    public void setItemClass(Integer itemClass) {
        this.itemClass = itemClass;
    }

    public Integer getItemSubClass() {
        return itemSubClass;
    }

    public void setItemSubClass(Integer itemSubClass) {
        this.itemSubClass = itemSubClass;
    }

    public Integer getContainerSlots() {
        return containerSlots;
    }

    public void setContainerSlots(Integer containerSlots) {
        this.containerSlots = containerSlots;
    }

    public Integer getInventoryType() {
        return inventoryType;
    }

    public void setInventoryType(Integer inventoryType) {
        this.inventoryType = inventoryType;
    }

    public Boolean getEquippable() {
        return equippable;
    }

    public void setEquippable(Boolean equippable) {
        this.equippable = equippable;
    }

    public Integer getItemLevel() {
        return itemLevel;
    }

    public void setItemLevel(Integer itemLevel) {
        this.itemLevel = itemLevel;
    }

    public Integer getMaxCount() {
        return maxCount;
    }

    public void setMaxCount(Integer maxCount) {
        this.maxCount = maxCount;
    }

    public Integer getMaxDurability() {
        return maxDurability;
    }

    public void setMaxDurability(Integer maxDurability) {
        this.maxDurability = maxDurability;
    }

    public Integer getMinFactionId() {
        return minFactionId;
    }

    public void setMinFactionId(Integer minFactionId) {
        this.minFactionId = minFactionId;
    }

    public Integer getMinReputation() {
        return minReputation;
    }

    public void setMinReputation(Integer minReputation) {
        this.minReputation = minReputation;
    }

    public Integer getQuality() {
        return quality;
    }

    public void setQuality(Integer quality) {
        this.quality = quality;
    }

    public Integer getSellPrice() {
        return sellPrice;
    }

    public void setSellPrice(Integer sellPrice) {
        this.sellPrice = sellPrice;
    }

    public Integer getRequiredSkill() {
        return requiredSkill;
    }

    public void setRequiredSkill(Integer requiredSkill) {
        this.requiredSkill = requiredSkill;
    }

    public Integer getRequiredLevel() {
        return requiredLevel;
    }

    public void setRequiredLevel(Integer requiredLevel) {
        this.requiredLevel = requiredLevel;
    }

    public Integer getRequiredSkillRank() {
        return requiredSkillRank;
    }

    public void setRequiredSkillRank(Integer requiredSkillRank) {
        this.requiredSkillRank = requiredSkillRank;
    }

    public ItemSource getItemSource() {
        return itemSource;
    }

    public void setItemSource(ItemSource itemSource) {
        this.itemSource = itemSource;
    }

    public Integer getBaseArmor() {
        return baseArmor;
    }

    public void setBaseArmor(Integer baseArmor) {
        this.baseArmor = baseArmor;
    }

    public Boolean getHasSockets() {
        return hasSockets;
    }

    public void setHasSockets(Boolean hasSockets) {
        this.hasSockets = hasSockets;
    }

    public Boolean getIsAuctionable() {
        return isAuctionable;
    }

    public void setIsAuctionable(Boolean isAuctionable) {
        this.isAuctionable = isAuctionable;
    }

    public Integer getArmor() {
        return armor;
    }

    public void setArmor(Integer armor) {
        this.armor = armor;
    }

    public Integer getDisplayInfoId() {
        return displayInfoId;
    }

    public void setDisplayInfoId(Integer displayInfoId) {
        this.displayInfoId = displayInfoId;
    }

    public String getNameDescription() {
        return nameDescription;
    }

    public String getNameDescriptionInformation() {
        if (nameDescription == null || nameDescription.isEmpty()) {
            return "";
        }
        return " from " + nameDescription;
    }

    public void setNameDescription(String nameDescription) {
        this.nameDescription = nameDescription;
    }

    public String getNameDescriptionColor() {
        return nameDescriptionColor;
    }

    public void setNameDescriptionColor(String nameDescriptionColor) {
        this.nameDescriptionColor = nameDescriptionColor;
    }

    public Boolean getUpgradable() {
        return upgradable;
    }

    public void setUpgradable(Boolean upgradable) {
        this.upgradable = upgradable;
    }

    public Boolean getHeroicTooltip() {
        return heroicTooltip;
    }

    public void setHeroicTooltip(Boolean heroicTooltip) {
        this.heroicTooltip = heroicTooltip;
    }

    public String getContext() {
        return context;
    }

    public String getItemFromContext() {
        String returnContext = "";
        if (context != null && !context.isEmpty()) {
            returnContext = " from " + getNormalizedContext();
        }
        return returnContext;
    }

    public void setContext(String context) {
        this.context = context;
    }

    public List<Integer> getBonusLists() {
        return bonusLists;
    }

    public void setBonusLists(List<Integer> bonusLists) {
        this.bonusLists = bonusLists;
    }

    public List<String> getAvailableContexts() {
        return availableContexts;
    }

    public void setAvailableContexts(List<String> availableContexts) {
        this.availableContexts = availableContexts;
    }

    public BonusSummary getBonusSummary() {
        return bonusSummary;
    }

    public void setBonusSummary(BonusSummary bonusSummary) {
        this.bonusSummary = bonusSummary;
    }

    public Integer getArtifactId() {
        return artifactId;
    }

    public void setArtifactId(Integer artifactId) {
        this.artifactId = artifactId;
    }

    public String getItemNameInWowColor() {
        return getColorFromQuality(getName());
    }

    private String getColorFromQuality(String name) {
        switch (quality) {
            case 2:
                return "[" + name + "]";
            case 3:
                return "[" + name + "]";
            case 4:
                return "[" + name + "]";
            case 5:
                return "[" + name + "]";
            default:
                return name;
        }
    }

    public String getNormalizedContext() {
        switch (context) {
            case "raid-finder":
                return addDescriptionContext("raid finder");
            case "raid-normal":
                return addDescriptionContext("normal raid");
            case "raid-heroic":
                return addDescriptionContext("heroic raid");
            case "raid-mythic":
                return addDescriptionContext("mythic raid");
            case "dungeon-level-up-1":
                return addDescriptionContext("dungeon level up(1)");
            case "dungeon-normal":
                return addDescriptionContext("normal dungeon");
            case "dungeon-heroic":
                return addDescriptionContext("heroic dungeon");
            case "dungeon-mythic":
                return addDescriptionContext("mythic dungeon");
            case "timewalker":
                return addDescriptionContext("timewalking dungeon");
            case "challenge-mode-jackpot":
                return addDescriptionContext("Weekly Mythic Chest");
            case "world-quest":
                return addDescriptionContext("world quest");
            case "pvp-ranked":
                return addDescriptionContext("ranked pvp");
            case "pvp-unranked":
                return addDescriptionContext("unranked pvp");
            default:
                break;
        }
        if (context.contains("world-quest-")) {
            return addDescriptionContext("world quest(" + context.replace("world-quest-", "") + ")");
        }

        if (context.contains("challenge-mode-")) {
            return addDescriptionContext("challenge mode dungeon(" + context.replace("challenge-mode-", "") + ")");
        }

        if (context.contains("pvp-ranked-")) {
            return "pvp-ranked(" + context.replace("pvp-ranked-", "") + ")";
        }

        if (context.contains("pvp-unranked-")) {
            return addDescriptionContext("pvp-unranked(" + context.replace("pvp-unranked-", "") + ")");
        }
        return context;
    }

    private String addDescriptionContext(String context) {
        if (nameDescription == null || nameDescription.isEmpty()) {
            return context;
        }
        return context + "-" + nameDescription;
    }
}


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

namespace Dms\Web\Expressive\Renderer\Form\Field;

use Dms\Common\Structure\FileSystem\Form\FileUploadType;
use Dms\Common\Structure\FileSystem\Form\ImageUploadType;
use Dms\Core\Form\Field\Type\ArrayOfType;
use Dms\Core\Form\Field\Type\FieldType;
use Dms\Core\Form\IField;
use Dms\Core\Form\IFieldType;
use Dms\Web\Expressive\Renderer\Form\FormRenderingContext;

/**
 * The array of files field renderer
 *
 * @author Elliot Levin <elliotlevin@hotmail.com>
 */
class ArrayOfFilesFieldsRenderer extends FileFieldRenderer
{
    /**
     * Gets the expected class of the field type for the field.
     *
     * @return array
     */
    public function getFieldTypeClasses() : array
    {
        return [ArrayOfType::class];
    }

    protected function canRender(FormRenderingContext $renderingContext, IField $field, IFieldType $fieldType) : bool
    {
        /**
         * @var ArrayOfType $fieldType
         */
        return !$fieldType->has(FieldType::ATTR_OPTIONS)
        && $fieldType->getElementType() instanceof FileUploadType;
    }

    protected function renderField(FormRenderingContext $renderingContext, IField $field, IFieldType $fieldType) : string
    {
        /**
         * @var ArrayOfType $fieldType
         */
        /**
         * @var FileUploadType $elementType
         */
        $elementType = $fieldType->getElementType();

        return $this->renderView(
            $field,
            'dms::components.field.dropzone.input',
            [
                ArrayOfType::ATTR_MIN_ELEMENTS   => 'minFiles',
                ArrayOfType::ATTR_MAX_ELEMENTS   => 'maxFiles',
                ArrayOfType::ATTR_EXACT_ELEMENTS => 'exactFiles',
            ],
            [
                'multiUpload'   => true,
                'maxFileSize'   => $elementType->get(FileUploadType::ATTR_MAX_SIZE),
                'minFileSize'   => $elementType->get(FileUploadType::ATTR_MIN_SIZE),
                'extensions'    => $elementType->get(FileUploadType::ATTR_EXTENSIONS),
                'existingFiles' => $this->getExistingFilesArray($field->getUnprocessedInitialValue() ?? []),

                'imagesOnly'     => $elementType instanceof ImageUploadType,
                'maxImageWidth'  => $elementType->get(ImageUploadType::ATTR_MAX_WIDTH),
                'maxImageHeight' => $elementType->get(ImageUploadType::ATTR_MAX_HEIGHT),
                'minImageWidth'  => $elementType->get(ImageUploadType::ATTR_MIN_WIDTH),
                'minImageHeight' => $elementType->get(ImageUploadType::ATTR_MIN_HEIGHT),
            ]
        );
    }

    protected function renderFieldValue(FormRenderingContext $renderingContext, IField $field, $value, IFieldType $fieldType) : string
    {
        return $this->renderValueViewWithNullDefault(
            $field,
            $value,
            'dms::components.field.dropzone.value',
            [
                'existingFiles' => $value !== null
                    ? $this->getExistingFilesArray($field->getUnprocessedInitialValue())
                    : null
            ]
        );
    }
}


text:
package dobs

import (
	"os"
	"strconv"
	"strings"
	"testing"

	log "github.com/Sirupsen/logrus"
	gofigCore "github.com/akutz/gofig"
	gofig "github.com/akutz/gofig/types"
	"github.com/codedellemc/libstorage/api/context"
	"github.com/codedellemc/libstorage/api/registry"
	"github.com/codedellemc/libstorage/api/server"
	apitests "github.com/codedellemc/libstorage/api/tests"
	"github.com/codedellemc/libstorage/api/types"
	"github.com/codedellemc/libstorage/api/utils"
	do "github.com/codedellemc/libstorage/drivers/storage/dobs"
	doUtils "github.com/codedellemc/libstorage/drivers/storage/dobs/utils"
	"github.com/stretchr/testify/assert"
)

var (
	configYAML = []byte(`
dobs:
  token: 12345
  region: sfo2`)
)

func skipTests() bool {
	travis, _ := strconv.ParseBool(os.Getenv("TRAVIS"))
	noTest, _ := strconv.ParseBool(os.Getenv("TEST_SKIP_DO"))
	return travis || noTest
}

var volumeName string
var volumeName2 string

func init() {
	uuid, _ := types.NewUUID()
	uuids := strings.Split(uuid.String(), "-")
	volumeName = uuids[0]
	if _, err := strconv.Atoi(string(volumeName[0])); err == nil {
		// TODO randomly select a-z here
		volumeName = strings.Join([]string{"a", volumeName[1:]}, "")
	}

	uuid, _ = types.NewUUID()
	uuids = strings.Split(uuid.String(), "-")
	volumeName2 = uuids[0]
	if _, err := strconv.Atoi(string(volumeName2[0])); err == nil {
		// TODO randomly select a-z here
		volumeName2 = strings.Join([]string{"a", volumeName2[1:]}, "")
	}
}

func TestMain(m *testing.M) {
	server.CloseOnAbort()
	ec := m.Run()
	os.Exit(ec)
}

func TestConfig(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}

	tfDO := func(config gofig.Config, client types.Client, t *testing.T) {
		assert.NotEqual(t, config.GetString(do.ConfigRegion), "")
		assert.NotEqual(t, config.GetString(do.ConfigToken), "")
	}

	apitests.Run(t, do.Name, configYAML, tfDO)
}

func TestInstanceID(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}

	sd, err := registry.NewStorageDriver(do.Name)
	if err != nil {
		t.Fatal(err)
	}

	ctx := context.Background()
	if err := sd.Init(ctx, gofigCore.New()); err != nil {
		t.Fatal(err)
	}

	iid, err := doUtils.InstanceID(ctx)
	if err != nil {
		t.Fatal(err.Error())
	}

	ctx = ctx.WithValue(context.InstanceIDKey, iid)
	i, err := sd.InstanceInspect(ctx, utils.NewStore())
	if err != nil {
		t.Fatal(err)
	}

	iid = i.InstanceID
	apitests.Run(
		t, do.Name, nil,
		(&apitests.InstanceIDTest{
			Driver:   do.Name,
			Expected: iid,
		}).Test)
}

func TestServices(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}

	tf := func(config gofig.Config, client types.Client, t *testing.T) {
		reply, err := client.API().Services(nil)
		assert.NoError(t, err)
		assert.Equal(t, len(reply), 1)

		_, ok := reply[do.Name]
		assert.True(t, ok)
	}

	apitests.Run(t, do.Name, configYAML, tf)
}

func TestVolumeAttach(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}
	var vol *types.Volume
	tf := func(config gofig.Config, client types.Client, t *testing.T) {
		vol = volumeCreate(t, client, volumeName)
		_ = volumeAttach(t, client, vol.ID)
		_ = volumeInspectAttached(t, client, vol.ID)
		_ = volumeInspectDetachedFail(t, client, vol.ID)
		_ = volumeDetach(t, client, vol.ID)
		_ = volumeInspectDetached(t, client, vol.ID)
		volumeRemove(t, client, vol.ID)
	}
	apitests.Run(t, do.Name, configYAML, tf)
}

func TestVolumeCreateRemove(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}

	tf := func(config gofig.Config, client types.Client, t *testing.T) {
		vol := volumeCreate(t, client, volumeName)
		volumeRemove(t, client, vol.ID)
	}

	apitests.Run(t, do.Name, configYAML, tf)
}

func TestVolumes(t *testing.T) {
	if skipTests() {
		t.SkipNow()
	}

	tf := func(config gofig.Config, client types.Client, t *testing.T) {
		_ = volumeCreate(t, client, volumeName)
		_ = volumeCreate(t, client, volumeName2)

		vol1 := volumeByName(t, client, volumeName)
		vol2 := volumeByName(t, client, volumeName2)

		volumeRemove(t, client, vol1.ID)
		volumeRemove(t, client, vol2.ID)
	}

	apitests.Run(t, do.Name, configYAML, tf)
}

// Test implementation functions

func volumeCreate(t *testing.T, client types.Client,
	volumeName string) *types.Volume {
	log.WithField("volumeName", volumeName).Info("creating volume")

	size := int64(10)
	opts := map[string]interface{}{
		"priority": 2,
		"owner":    "libstorage@example.com",
	}

	volumeCreateRequest := &types.VolumeCreateRequest{
		Name: volumeName,
		Size: &size,
		Opts: opts,
	}

	// Send request and retrieve created libStorage types.Volume
	reply, err := client.API().VolumeCreate(
		nil, do.Name, volumeCreateRequest)
	assert.NoError(t, err)
	if err != nil {
		t.FailNow()
		t.Error("failed volumeCreate")
	}
	apitests.LogAsJSON(reply, t)

	// Check if name and size are same
	assert.Equal(t, volumeName, reply.Name)
	assert.Equal(t, size, reply.Size)
	return reply
}

func volumeByName(
	t *testing.T, client types.Client, volumeName string) *types.Volume {
	log.WithField("volumeName", volumeName).Info(
		"get volume by digitalocean.Name")
	vols, err := client.API().Volumes(nil, 0)
	assert.NoError(t, err)
	if err != nil {
		t.FailNow()
	}

	assert.Contains(t, vols, do.Name)
	for _, vol := range vols[do.Name] {
		if vol.Name == volumeName {
			return vol
		}
	}
	// No matching volumes found
	t.FailNow()
	t.Error("failed volumeByName")
	return nil
}

func volumeByID(
	t *testing.T, client types.Client, volumeID string) *types.Volume {
	log.WithField("volumeID", volumeID).Info(
		"get volume by digitalocean.Name using ID")
	// Retrieve all volumes
	vols, err := client.API().Volumes(nil, 0)
	assert.NoError(t, err)
	if err != nil {
		t.FailNow()
	}
	// Filter volumes to those under the digitalocean service,
	// and find a volume matching inputted volume ID
	assert.Contains(t, vols, do.Name)
	for _, vol := range vols[do.Name] {
		if vol.ID == volumeID {
			return vol
		}
	}
	// No matching volumes found
	t.FailNow()
	t.Error("failed volumeByID")
	return nil
}

func volumeRemove(t *testing.T, client types.Client, volumeID string) {
	log.WithField("volumeID", volumeID).Info("removing volume")
	err := client.API().VolumeRemove(nil, do.Name, volumeID, false)

	assert.NoError(t, err)
	if err != nil {
		t.Error("failed volumeRemove")
		t.FailNow()
	}
}

func volumeAttach(
	t *testing.T, client types.Client, volumeID string) *types.Volume {
	log.WithField("volumeID", volumeID).Info("attaching volume")

	reply, token, err := client.API().VolumeAttach(
		nil, do.Name, volumeID, &types.VolumeAttachRequest{})

	assert.NoError(t, err)
	if err != nil {
		t.Error("failed volumeAttach")
		t.FailNow()
	}
	apitests.LogAsJSON(reply, t)
	assert.NotEqual(t, token, "")

	return reply
}

func volumeInspectAttached(
	t *testing.T, client types.Client, volumeID string) *types.Volume {
	log.WithField("volumeID", volumeID).Info("inspecting volume")

	reply, err := client.API().VolumeInspect(
		nil, do.Name, volumeID,
		types.VolAttReqTrue)
	assert.NoError(t, err)

	if err != nil {
		t.Error("failed volumeInspectAttached")
		t.FailNow()
	}
	apitests.LogAsJSON(reply, t)
	assert.Len(t, reply.Attachments, 1)
	return reply
}

func volumeInspectDetached(
	t *testing.T, client types.Client, volumeID string) *types.Volume {
	log.WithField("volumeID", volumeID).Info("inspecting volume")

	reply, err := client.API().VolumeInspect(
		nil, do.Name, volumeID,
		types.VolAttReq)

	assert.NoError(t, err)
	if err != nil {
		t.Error("failed volumeInspectDetached")
		t.FailNow()
	}

	apitests.LogAsJSON(reply, t)
	assert.Len(t, reply.Attachments, 0)
	return reply
}

func volumeInspectDetachedFail(
	t *testing.T, client types.Client, volumeID string) *types.Volume {

	log.WithField("volumeID", volumeID).Info("inspecting volume")
	reply, err := client.API().VolumeInspect(nil, do.Name, volumeID, 0)
	assert.NoError(t, err)

	if err != nil {
		t.Error("failed volumeInspectDetachedFail")
		t.FailNow()
	}
	apitests.LogAsJSON(reply, t)
	assert.Len(t, reply.Attachments, 0)
	return reply
}

func volumeDetach(
	t *testing.T, client types.Client, volumeID string) *types.Volume {
	log.WithField("volumeID", volumeID).Info("detaching volume")

	reply, err := client.API().VolumeDetach(
		nil, do.Name, volumeID, &types.VolumeDetachRequest{})

	assert.NoError(t, err)
	if err != nil {
		t.Error("failed volumeDetach")
		t.FailNow()
	}
	apitests.LogAsJSON(reply, t)
	assert.Len(t, reply.Attachments, 0)
	return reply
}


text:
namespace pdalboost {} namespace boost = pdalboost; namespace pdalboost { namespace geometry
{

#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
namespace traits
{

#ifndef DOXYGEN_NO_DETAIL
namespace detail
{

// Create class and specialization to indicate the tag
// for normal cases and the case that the type of the c-array is arithmetic
template <bool>
struct c_array_tag
{
    typedef geometry_not_recognized_tag type;
};

template <>
struct c_array_tag<true>
{
    typedef point_tag type;
};

} // namespace detail
#endif // DOXYGEN_NO_DETAIL

// Assign the point-tag, preventing arrays of points getting a point-tag
template <typename CoordinateType, std::size_t DimensionCount>
struct tag<CoordinateType[DimensionCount]>
    : detail::c_array_tag<pdalboost::is_arithmetic<CoordinateType>::value> {};

template <typename CoordinateType, std::size_t DimensionCount>
struct coordinate_type<CoordinateType[DimensionCount]>
{
    typedef CoordinateType type;
};

template <typename CoordinateType, std::size_t DimensionCount>
struct dimension<CoordinateType[DimensionCount]>: pdalboost::mpl::int_<DimensionCount> {};

template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension>
struct access<CoordinateType[DimensionCount], Dimension>
{
    static inline CoordinateType get(CoordinateType const p[DimensionCount])
    {
        return p[Dimension];
    }

    static inline void set(CoordinateType p[DimensionCount],
        CoordinateType const& value)
    {
        p[Dimension] = value;
    }
};

} // namespace traits
#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS

}} // namespace pdalboost::geometry

#define BOOST_GEOMETRY_REGISTER_C_ARRAY_CS(CoordinateSystem) \
    namespace pdalboost {} namespace boost = pdalboost; namespace pdalboost { namespace geometry { namespace traits { \
    template <typename T, std::size_t N> \
    struct coordinate_system<T[N]> \
    { \
        typedef CoordinateSystem type; \
    }; \
    }}}

#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_C_ARRAY_HPP


text:
using System;
using System.Diagnostics;
using System.Threading;
using Common.Logging;
using NCmdLiner;
using NCmdLiner.Exceptions;
using _S_ConsoleProjectName_S_.Infrastructure;
using _S_LibraryProjectName_S_.Infrastructure;

namespace _S_ConsoleProjectName_S_
{
    class Program
    {
        [STAThread]
        static int Main(string[] args)
        {
            int returnValue;
            try
            {
                returnValue = WireUpAndRun(args);
            }
            catch (Exception ex)
            {
                var message = string.Format("Fatal error when wiring up the application.{0}{1}", Environment.NewLine, ex);
                WriteErrorToEventLog(message);
                returnValue = 3;
            }
            return returnValue;
        }

        private static int WireUpAndRun(string[] args)
        {
            var returnValue = 0;
            var logger = GetMainLogger();
            using (var bootStrapper = new BootStrapper())
            {
                var applicationInfo = bootStrapper.Container.Resolve<IApplicationInfo>();
                try
                {
                    applicationInfo.Authors = @"_S_Authors_S_";
                    // ReSharper disable once CoVariantArrayConversion
                    object[] commandTargets = bootStrapper.Container.ResolveAll<CommandDefinition>();
                    logger.InfoFormat("Start: {0}.{1}. Command line: {2}", applicationInfo.Name, applicationInfo.Version, Environment.CommandLine);
                    returnValue = CmdLinery.Run(commandTargets, args, applicationInfo, bootStrapper.Container.Resolve<IMessenger>());
                    return returnValue;
                }
                catch (MissingCommandException ex)
                {
                    logger.ErrorFormat("Missing command. {0}", ex.Message);
                    returnValue = 1;
                }
                catch (UnknownCommandException ex)
                {
                    logger.Error(ex.Message);
                    returnValue = 1;
                }
                catch (Exception ex)
                {
                    logger.ErrorFormat("Error when exeuting command. {0}", ex.ToString());
                    returnValue = 2;
                }
                finally
                {
                    logger.InfoFormat("Stop: {0}.{1}. Return value: {2}", applicationInfo.Name, applicationInfo.Version, returnValue);
#if DEBUG
                    // ReSharper disable once RedundantNameQualifier
                    System.Console.WriteLine("Terminating in 5 seconds...");
                    Thread.Sleep(5000);
#endif
                }
            }
            return returnValue;
        }

        private static ILog GetMainLogger()
        {
            try
            {
                var logger = LogManager.GetLogger<Program>();
                return logger;
            }
            catch (Exception ex)
            {
                throw new Exception("Failed to get logger. ", ex);
            }
        }

        private static void WriteErrorToEventLog(string message)
        {
            // ReSharper disable once RedundantNameQualifier
            System.Console.WriteLine(message);
            const string logName = "Application";
            using (var eventLog = new EventLog(logName))
            {
                eventLog.Source = logName;
                eventLog.WriteEntry(message, EventLogEntryType.Information, 101, 1);
            }
        }

    }
}


text:
<?php echo AT_print($this->row['question'], 'tests_questions.question'); ?>

	<?php for ($i=0; $i < 10; $i++): ?>
		<?php if ($this->row['choice_'.$i] != ''): ?>

				<?php if (($this->row['answer_'.$i] == 1) && in_array($i, $this->answers)): ?>
					<img src="<?php echo $this->base_path; ?>images/checkmark.gif" alt="<?php echo _AT('correct_answer'); ?>" title="<?php echo _AT('correct_answer'); ?>" height="16" width="16" style="vertical-align: middle" />
				<?php elseif (($this->row['weight'] > 0) && (($this->row['answer_'.$i] == 0) || in_array($i, $this->answers))): ?>
					<img src="<?php echo $this->base_path; ?>images/x.gif" alt="<?php echo _AT('wrong_answer'); ?>" title="<?php echo _AT('wrong_answer'); ?>" height="16" width="16" style="vertical-align: middle" />
				<?php else: ?>
					<img src="<?php echo $this->base_path; ?>images/clr.gif" alt="" title="" height="16" width="16" style="vertical-align: middle" />
				<?php endif; ?>

				<?php if (in_array($i, $this->answers)): ?>
					<img src="<?php echo $this->base_path; ?>images/checkbox_check.gif" alt="<?php echo _AT('checked'); ?>" title="<?php echo _AT('checked'); ?>" height="13" width="13" style="vertical-align: middle" />
				<?php else: ?>
					<img src="<?php echo $this->base_path; ?>images/checkbox_empty.gif" alt="<?php echo _AT('unchecked'); ?>" title="<?php echo _AT('unchecked'); ?>" height="13" width="13" style="vertical-align: middle" />
				<?php endif; ?>
				<?php echo AT_print($this->row['choice_'.$i], 'tests_questions.choice_'.$i); ?>
		<?php endif; ?>
	<?php endfor; ?>


text:
import socket
import ssl

from Configuration import Properties
from IOSocket.IOTransport import IoTransport

class SSLSocket(IoTransport):
    def __init__(self):
        Context = self.__loadContext()
        self._SSL_Sock = ssl.wrap_socket(socket.socket(socket.AF_INET, socket.SOCK_STREAM),
                                         ca_certs=Properties.Server_Cert,
                                         cert_reqs=ssl.CERT_REQUIRED,
                                         ssl_version=ssl.PROTOCOL_TLSv1)
        super(SSLSocket, self).__init__(self._SSL_Sock)

    def __loadContext(self):
        context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
        context.verify_mode = ssl.CERT_REQUIRED
        context.check_hostname = True
        return context

    def __connect(self, host, port):
        super(SSLSocket, self).__connect()

    def __Send__(self, msg, MSGLEN):
        super(SSLSocket, self).__Send__(msg, MSGLEN)

    def __Receive__(self):
        return super(SSLSocket, self).__Receive__()

    def __Close__(self):
        super(SSLSocket, self).__Close__()

    @property
    def Socket(self):
        return self._sock


text:
package org.scalex
package cli

private[cli] object Parser {

  def parse(args: Array[String]) = (new scopt.OptionParser[Config]("scalex") {
    head("scalex", "3.0")
    cmd("search") action { (_, c) ⇒
      c.copy(search = api.Search().some)
    } text ("Search the index") children {
      arg[String]("<expr>...") required () unbounded () action { (x, c) ⇒
        c.withSearch(_ add x)
      } text ("Search words")
    }
  }) parse (args, Config())
}


text:
package net.coscolla.comicstrip.net.api;

import net.coscolla.comicstrip.entities.Strip;

public class UrlBuilder {

  private final String endpoint;

  public UrlBuilder(String endpoint) {
    this.endpoint = endpoint;
  }

  public String urlThumbnail(Strip strip) {
    return endpoint +  "comics/thumbnail/" + strip._id;
  }

  public String urlImage(String stripId) {
    return endpoint + "comics/image/" + stripId;
  }
}


text:
import React from "react";
import Header from "./Header.js";
import {RouteHandler} from "react-router"

class App extends React.Component {

    render () {

      return (

                  <RouteHandler />

      );
    }
}

export default App


text:
package io.authup.android.apps.authenticator;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Hashtable;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

import android.graphics.Bitmap;
import android.graphics.Color;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.WriterException;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.QRCodeWriter;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;

/**
 * @author Andreas Schildbach
 */
public class Qr
{
	private final static QRCodeWriter QR_CODE_WRITER = new QRCodeWriter();

	public static Bitmap bitmap(final String content, final int size) {
		try {
			final Hashtable<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
			hints.put(EncodeHintType.MARGIN, 0);
			hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
			final BitMatrix result = QR_CODE_WRITER.encode(content, BarcodeFormat.QR_CODE, size, size, hints);

			final int width = result.getWidth();
			final int height = result.getHeight();
			final int[] pixels = new int[width * height];

			for (int y = 0; y < height; y++) {
				final int offset = y * width;
				for (int x = 0; x < width; x++) {
					pixels[offset + x] = result.get(x, y) ? Color.BLACK : Color.TRANSPARENT;
				}
			}

			final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
			bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
			return bitmap;
		} catch (final WriterException x) {
			return null;
		}
	}
}


text:
namespace Snippets6.Callback.Enum
{
    public enum Status
    {
        OK,
        Error
    }
}


text:
using UnityEngine;
using System.Collections;

/// <summary>
/// GUI manager.
/// Contains help functions to draw stuff.
/// </summary>
public class GUIManager : MonoBehaviour
{
	#region Fields

	// GUIStyles
	public static GUIStyle titleStyle;
	public static GUIStyle headerStyle;
	public static GUIStyle labelStyle;
	public static GUIStyle centeredLabelStyle;
	public static GUIStyle largeCenteredLabelStyle;
	public static GUIStyle boldLabelStyle;
	public static GUIStyle multilineLabelStyle;
	public static GUIStyle boldMultilineLabelStyle;
	public static GUIStyle debugLabelStyle;
	public static GUIStyle noteGroup;

	public static GUIStyle rightGreenButtonStyle;
	public static GUIStyle rightRedButtonStyle;
	public static GUIStyle leftRedButtonStyle;
	public static GUIStyle drawnButtonStyle;

	// Virtual screen sizes.
	public static float virtualWidth;
	public static float virtualHeight;

	// Font
	private static Font noteFont;

	// Background texture
	public static GUITexture bookBackground;

	// 3D models
	public static GameObject treasureChest;

	// Arrow texture
	private static Texture2D arrowTexture;
	private static Texture2D compassArrowTexture;

	// Map pieces
	private static Texture2D mapPiece1;
	private static Texture2D mapPiece2;
	private static Texture2D mapPiece3;
	private static Texture2D mapPiece4;

	// GUI shadows
	private static Texture2D leftShadow;
	private static Texture2D rightShadow;
	private static Texture2D noteShadow;

	private static Texture2D mapPiece1Shadow;
	private static Texture2D mapPiece2Shadow;
	private static Texture2D mapPiece3Shadow;
	private static Texture2D mapPiece4Shadow;

	// GUI Styles initialized only once.
	public static bool init;

	#endregion

	#region MonoBehaviour Methods

	/// <summary>
	/// MonoBehaviour Start method.
	/// </summary>
	void Start()
	{
		// Setup screen sizes
		Screen.orientation = ScreenOrientation.LandscapeLeft;
		virtualWidth = 1920.0f;
		virtualHeight = 1104.0f;

		// Instantiate 3D models.
		treasureChest = Instantiate(Resources.Load("Prefabs/TreasureChest")) as GameObject;
		treasureChest.name = "TreasureChest";
		treasureChest.SetActive(false);

		// Load font.
		noteFont = Resources.Load("Fonts/NoteFont") as Font;

		// Instantiate background texture.
		bookBackground = (new GameObject("GUIBookBackground")).AddComponent<GUITexture>();
		bookBackground.guiTexture.texture = Resources.Load ("Images/Backgrounds/BookBackground") as Texture2D;
		bookBackground.guiTexture.pixelInset = new Rect(-virtualWidth/2, -virtualHeight/2, virtualWidth, virtualHeight);
		bookBackground.transform.localPosition = new Vector3(0.5f, 0.5f, 0);
		bookBackground.transform.localScale = new Vector3(0, 0, 1);
		bookBackground.gameObject.layer = 8;

		// Load arrow texture.
		arrowTexture = Resources.Load("Images/Arrow") as Texture2D;
		compassArrowTexture = Resources.Load("Images/CompassArrow") as Texture2D;

		// Load map pieces.
		mapPiece1 = Resources.Load("Images/Map/MapPiece1") as Texture2D;
		mapPiece2 = Resources.Load("Images/Map/MapPiece2") as Texture2D;
		mapPiece3 = Resources.Load("Images/Map/MapPiece3") as Texture2D;
		mapPiece4 = Resources.Load("Images/Map/MapPiece4") as Texture2D;

		// Load shadows.
		leftShadow = Resources.Load("Images/Buttons/LeftRibbonShadow") as Texture2D;
		rightShadow = Resources.Load("Images/Buttons/RightRibbonShadow") as Texture2D;
		noteShadow = Resources.Load("Images/Backgrounds/NoteShadow") as Texture2D;

		mapPiece1Shadow = Resources.Load("Images/Map/MapPiece1Shadow") as Texture2D;
		mapPiece2Shadow = Resources.Load("Images/Map/MapPiece2Shadow") as Texture2D;
		mapPiece3Shadow = Resources.Load("Images/Map/MapPiece3Shadow") as Texture2D;
		mapPiece4Shadow = Resources.Load("Images/Map/MapPiece4Shadow") as Texture2D;
	}

	#endregion

	#region Public methods called from GameStateManager

	/// <summary>
	/// OnUpdate method called by GameStateManager.
	/// </summary>
	public static void OnUpdate()
	{
		// Draw the background texture according to the current screensize
		bookBackground.guiTexture.pixelInset = new Rect(-Screen.width/2, -Screen.height/2, Screen.width, Screen.height);
	}

	/// <summary>
	/// OnDisplay method called by GameStateManager.
	/// </summary>
	public static void OnDisplay()
	{
		// Scale the whole GUI according to the screen size
		GUI.matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(Screen.width / virtualWidth, Screen.height / virtualHeight, 1.0f));
	}

	#endregion

	#region GUI helper functions

	// Delegate for Buttons
	public delegate void OnClick();

	// Delegate for groups
	public delegate void DrawGroupContents(float width, float height);

	// Draw labels

	/// <summary>
	/// Draw a centered label around x, y coordinates with specified GUI style.
	/// </summary>
	/// <param name="str">String.</param>
	/// <param name="x">The x coordinate.</param>
	/// <param name="y">The y coordinate.</param>
	/// <param name="style">Style.</param>
	public static void CenteredLabel(string str, float x, float y, GUIStyle style)
	{
		Rect rect = GUILayoutUtility.GetRect(new GUIContent(str), style);
		rect.x = x - rect.width/2;
		rect.y = y;
		GUI.Label(rect, str, style);
	}

	/// <summary>
	/// Draw a centered label around x, y coordinates with default GUI style.
	/// </summary>
	/// <param name="str">String.</param>
	/// <param name="x">The x coordinate.</param>
	/// <param name="y">The y coordinate.</param>
	public static void CenteredLabel(string str, float x, float y)
	{
		CenteredLabel(str, x, y, centeredLabelStyle);
	}

	/// <summary>
	/// Draws a page title.
	/// </summary>
	/// <param name="title">Title text.</param>
	public static void PageTitle(string title)
	{
		Rect titleRect = GUILayoutUtility.GetRect(new GUIContent(title), GUIManager.headerStyle);
		titleRect.x = virtualWidth/4 - titleRect.width/2;
		titleRect.y = virtualHeight/8;
		GUI.Label(titleRect, title, GUIManager.headerStyle);
	}

	// Draw arrow

	/// <summary>
	/// Draws arrow on left page.
	/// </summary>
	/// <param name="angle">Angle.</param>
	public static void DrawArrowLeft(float angle)
	{
		float arrowWidth = 3*arrowTexture.width/4;
		float arrowHeight = 3*arrowTexture.height/4;
		float arrowX = virtualWidth/4 - arrowWidth/2;
		float arrowY = (virtualHeight - arrowHeight) / 2;

		Vector2 pivot = new Vector2(Screen.width/4, Screen.height/2);
		Rect arrowRect = new Rect(arrowX, arrowY, arrowWidth, arrowHeight);

		DrawArrow(arrowRect, pivot, angle);
	}

	/// <summary>
	/// Draws arrow on right page.
	/// </summary>
	/// <param name="angle">Angle.</param>
	public static void DrawArrowRight(float angle)
	{
		float arrowWidth = 3*arrowTexture.width/4;
		float arrowHeight = 3*arrowTexture.height/4;
		float arrowX = virtualWidth/2 + virtualWidth/4 - arrowWidth/2;
		float arrowY = (virtualHeight - arrowHeight) / 2;

		Vector2 pivot = new Vector2(3*Screen.width/4, Screen.height/2);
		Rect arrowRect = new Rect(arrowX, arrowY, arrowWidth, arrowHeight);

		DrawArrow(arrowRect, pivot, angle);
	}

	// Internal draw arrow function.
	private static void DrawArrow(Rect rect, Vector2 pivot, float angle)
	{
		RotatedTexture(rect, arrowTexture, angle, pivot);
	}

	// Internal draw compass arrow function.
	private static void DrawCompassArrow(Rect rect, Vector2 pivot, float angle)
	{
		RotatedTexture(rect, compassArrowTexture, angle, pivot);
	}

	// Draw groups

	/// <summary>
	/// Draw a popover with one button.
	/// </summary>
	/// <param name="text">Popover text.</param>
	/// <param name="buttonText">Button text.</param>
	/// <param name="buttonClick">Button OnClick delegate.</param>
	public static void PopoverOneButton(string text, string buttonText, OnClick buttonClick)
	{
		GroupNote(delegate(float width, float height) {
			Rect textRect = GUILayoutUtility.GetRect(new GUIContent(text), GUIManager.headerStyle);
			textRect.x = width/2.0f - textRect.width/2.0f;
			textRect.y = height/6.0f;
			GUI.Label(textRect, text, GUIManager.headerStyle);

			Rect buttonRect = GUILayoutUtility.GetRect(new GUIContent(buttonText), GUIManager.drawnButtonStyle);
			buttonRect.width = width/2;
			buttonRect.height = height/8;
			buttonRect.x = (width - buttonRect.width)/2.0f;
			buttonRect.y = height * 0.7f;

			DrawnButton(buttonRect, buttonText, buttonClick);
		});
	}
	/// <summary>
	/// Draw a popover with two buttons.
	/// </summary>
	/// <param name="text">Popover text.</param>
	/// <param name="leftButtonText">Left button text.</param>
	/// <param name="leftButtonClick">Left button OnClick delegate.</param>
	/// <param name="rightButtonText">Right button text.</param>
	/// <param name="rightButtonClick">Right button OnClick delegate.</param>
	public static void PopoverTwoButtons(string text, string leftButtonText, OnClick leftButtonClick, string rightButtonText, OnClick rightButtonClick)
	{
		GroupNote(delegate(float width, float height) {
			Rect textRect = GUILayoutUtility.GetRect(new GUIContent(text), GUIManager.headerStyle);
			textRect.x = width/2.0f - textRect.width/2.0f;
			textRect.y = height/6.0f;
			GUI.Label(textRect, text, GUIManager.headerStyle);

			DrawnButton(new Rect(0.2f*width, 0.7f*height, width/4, height/8), leftButtonText, leftButtonClick);
			DrawnButton(new Rect(0.8f*width -width/4, 0.7f*height, width/4, height/8), rightButtonText, rightButtonClick);
		});
	}

	/// <summary>
	/// Draw a compass popover.
	/// </summary>
	/// <param name="angle">Angle.</param>
	/// <param name="buttonClick">Button OnClick delegate.</param>
	public static void PopoverCompass(float angle, OnClick buttonClick)
	{
		float noteWidth = virtualWidth * 0.5f;
		float noteHeight = virtualHeight * 0.9f;
		float noteX = virtualWidth * 0.25f;
		float noteY = virtualHeight * 0.05f;

		Rect note = new Rect(noteX, noteY, noteWidth, noteHeight);
		Rect shadow = new Rect(noteX+10, noteY+10, noteWidth, noteHeight);

		GUI.DrawTexture(shadow, GUIManager.noteShadow);
		GUI.BeginGroup(note, GUIManager.noteGroup);

		Rect buttonRect = GUILayoutUtility.GetRect(new GUIContent("Back"), GUIManager.drawnButtonStyle);
		buttonRect.width = noteWidth/2;
		buttonRect.height = noteHeight/8;
		buttonRect.x = (noteWidth - buttonRect.width)/2.0f;
		buttonRect.y = noteHeight * 0.75f;
		DrawnButton(buttonRect, "Back", buttonClick);

		GUI.EndGroup();

		float arrowWidth = 3*arrowTexture.width/4;
		float arrowHeight = 3*arrowTexture.height/4;
		float arrowX = (virtualWidth - arrowWidth) / 2;
		float arrowY = (virtualHeight - arrowHeight) / 2 - virtualHeight/10;

		Vector2 pivot = new Vector2(Screen.width/2, Screen.height/2 - Screen.height/10);
		Rect arrowRect = new Rect(arrowX, arrowY, arrowWidth, arrowHeight);

		DrawCompassArrow(arrowRect, pivot, angle);
	}

	// Internal draw group note popover.
	private static void GroupNote(DrawGroupContents dgc)
	{
		float noteWidth = virtualWidth * 0.8f;
		float noteHeight = virtualHeight * 0.8f;
		float noteX = virtualWidth * 0.1f;
		float noteY = virtualHeight * 0.1f;

		Rect note = new Rect(noteX, noteY, noteWidth, noteHeight);
		Rect shadow = new Rect(noteX+10, noteY+10, noteWidth, noteHeight);

		GUI.DrawTexture(shadow, GUIManager.noteShadow);
		GUI.BeginGroup(note, GUIManager.noteGroup);
		dgc(note.width, note.height);
		GUI.EndGroup();
	}

	/// <summary>
	/// Draws a left page.
	/// </summary>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void GroupLeftPage(DrawGroupContents dgc)
	{
		float halfWidth = virtualWidth/2;
		Rect g = new Rect(0.05f*halfWidth, 0.15f*virtualHeight, 0.9f*halfWidth, 0.8f*virtualHeight);
		Group(g, dgc);
	}

	/// <summary>
	/// Draws a slightly bigger left page.
	/// </summary>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void GroupLeftPageExtended(DrawGroupContents dgc)
	{
		float halfWidth = virtualWidth/2;
		Rect g = new Rect(0.05f*halfWidth, 0.05f*virtualHeight, 0.9f*halfWidth, 0.9f*virtualHeight);
		Group(g, dgc);
	}

	/// <summary>
	/// Draws a right page.
	/// </summary>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void GroupRightPage(DrawGroupContents dgc)
	{
		float halfWidth = virtualWidth/2;
		Rect g = new Rect(1.05f*halfWidth, 0.15f*virtualHeight, 0.9f*halfWidth, 0.8f*virtualHeight);
		Group(g, dgc);
	}

	/// <summary>
	/// Draws a slightly bigger right page.
	/// </summary>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void GroupRightPageExtended(DrawGroupContents dgc)
	{
		float halfWidth = virtualWidth/2;
		Rect g = new Rect(1.05f*halfWidth, 0.05f*virtualHeight, 0.9f*halfWidth, 0.9f*virtualHeight);
		Group(g, dgc);
	}

	/// <summary>
	/// Draw a leaderboard page. (Different size)
	/// </summary>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void GroupLeaderboard(DrawGroupContents dgc)
	{
		float halfWidth = virtualWidth/2;
		Rect g = new Rect(1.05f*halfWidth, 0.05f*virtualHeight, 0.95f*halfWidth, 0.9f*virtualHeight);
		Group(g, dgc);
	}

	/// <summary>
	/// Draw group.
	/// </summary>
	/// <param name="groupRect">Group rect.</param>
	/// <param name="dgc">DrawGroupContents delegate.</param>
	public static void Group(Rect groupRect, DrawGroupContents dgc)
	{
		GUI.BeginGroup(groupRect);
		dgc(groupRect.width, groupRect.height);
		GUI.EndGroup();
	}

	/// <summary>
	/// Draw a rotated texture.
	/// </summary>
	/// <param name="rect">Rect.</param>
	/// <param name="texture">Texture.</param>
	/// <param name="angle">Angle.</param>
	/// <param name="pivot">Pivot point.</param>
	public static void RotatedTexture(Rect rect, Texture texture, float angle, Vector2 pivot)
	{
		GUIUtility.RotateAroundPivot(angle, pivot);
		GUI.DrawTexture(rect, texture, ScaleMode.ScaleToFit, true, 0);
		GUIUtility.RotateAroundPivot(-angle, pivot);
	}

	// Draw buttons

	/// <summary>
	/// Draw a back button.
	/// </summary>
	/// <param name="click">Button OnClick delegate.</param>
	public static void BackButton(OnClick click)
	{
		TopLeftButton("     Back", click);
	}

	/// <summary>
	/// Draw a button on the top left of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void TopLeftButton(string text, OnClick click)
	{
		float w = virtualWidth/7.5f;
		float h = virtualHeight/11;
		float x = 0;
		float y = virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x, y+10, w+10, h);
		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, leftShadow);
		}

		DrawButton(button, text, GUIManager.leftRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a button on the top right of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void TopRightButton(string text, OnClick click)
	{
		float w = virtualWidth/7.5f;
		float h = virtualHeight/11;
		float x = virtualWidth - w;
		float y = virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x+10, y+10, w, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, rightShadow);
		}

		DrawButton(button, text, GUIManager.rightRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a button on the bottom left of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void BottomLeftButton(string text, OnClick click)
	{
		float w = virtualWidth/7.5f;
		float h = virtualHeight/11;
		float x = 0;
		float y = virtualHeight - h - virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x, y+10, w+10, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, leftShadow);
		}

		DrawButton(button, text, GUIManager.leftRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a button on the bottom right of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void BottomRightButton(string text, OnClick click)
	{
		float w = virtualWidth/7.5f;
		float h = virtualHeight/11;
		float x = virtualWidth - w;
		float y = virtualHeight - h - virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x+10, y+10, w, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, rightShadow);
		}

		DrawButton(button, text, GUIManager.rightRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a bigger button on the bottom left of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void BottomLeftButtonLarge(string text, OnClick click)
	{
		float w = virtualWidth/2.5f;
		float h = virtualHeight/11;
		float x = 0;
		float y = virtualHeight - h - virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x, y+10, w+10, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, leftShadow);
		}

		DrawButton(button, text, GUIManager.leftRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a bigger button on the bottom right of the screen.
	/// </summary>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void BottomRightButtonLarge(string text, OnClick click)
	{
		float w = virtualWidth/2.5f;
		float h = virtualHeight/11;
		float x = virtualWidth - w;
		float y = virtualHeight - h - virtualHeight/22;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x+10, y+10, w, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, rightShadow);
		}

		DrawButton(button, text, GUIManager.rightRedButtonStyle, click);
	}

	/// <summary>
	/// Draw a button in the popover note style.
	/// </summary>
	/// <param name="rect">Rect.</param>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void DrawnButton(Rect rect, string text, OnClick click)
	{
		DrawButton(rect, text, GUIManager.drawnButtonStyle, click);
	}

	/// <summary>
	/// Draws a menu button.
	/// </summary>
	/// <param name="i">Position in menu.</param>
	/// <param name="text">Button text.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void MenuButton(int i, string text, OnClick click)
	{
		float dy = (virtualHeight - 4f*150f)/5f;
		float x = virtualWidth - 800;
		float y = (i-1) * 150 + i * dy;
		float w = 800;
		float h = 150;

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x+10, y+10, w, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, rightShadow);
		}

		DrawButton(button, text, GUIManager.rightRedButtonStyle, click);
	}

	/// <summary>
	/// Draws a chapter button.
	/// </summary>
	/// <param name="i">Position in index.</param>
	/// <param name="text">Button text.</param>
	/// <param name="read">If set to <c>true</c> display as read.</param>
	/// <param name="click">Button OnClick delegate.</param>
	public static void ChapterButton(int i, string text, bool read, OnClick click)
	{
		GUIStyle buttonStyle;
		if (read)
		{
			buttonStyle = GUIManager.rightRedButtonStyle;
		}
		else
		{
			buttonStyle = GUIManager.rightGreenButtonStyle;
		}
		float w = 800;
		float h = 80;

		float offsetY = 75;
		float dy = (virtualHeight - 9*h - 2*offsetY)/8.0f;

		float x = virtualWidth - 800;
		float y = offsetY + i *(h+dy);

		Rect button = new Rect(x, y, w, h);
		Rect shadow = new Rect(x+10, y+10, w, h);

		if (GUI.enabled)
		{
			GUI.DrawTexture(shadow, rightShadow);
		}

		DrawButton(button, text, buttonStyle, click);
	}

	// Internal draw button function.
	private static void DrawButton(Rect rect, string text, GUIStyle style, OnClick click)
	{
		if (GUI.Button(rect, text, style))
		{
			SoundManager.Instance.PlaySound(SoundManager.pageSound);
			click();
		}
	}

	// Draw map pieces

	/// <summary>
	/// Draws map piece #1.
	/// </summary>
	public static void FirstMapPiece()
	{
		float imageWidth = mapPiece1.width*0.4f;
		float imageHeight = mapPiece1.height*0.4f;

		float noteX = virtualWidth * 0.1f;
		float noteY = virtualHeight * 0.1f;

		float imageX = noteX - 80;
		float imageY = noteY - 80;

		Rect mapPiece = new Rect(imageX, imageY, imageWidth, imageHeight);
		Rect mapPieceShadow = new Rect(imageX+10, imageY+10, imageWidth, imageHeight);

		GUIManager.RotatedTexture(mapPieceShadow, mapPiece1Shadow, -2.0f, new Vector2(noteX, noteY));
		GUIManager.RotatedTexture(mapPiece, mapPiece1, -2.0f, new Vector2(noteX, noteY));
	}

	/// <summary>
	/// Draws map piece #2.
	/// </summary>
	public static void SecondMapPiece()
	{
		float imageWidth = mapPiece1.width*0.4f;
		float imageHeight = mapPiece1.height*0.4f;

		float noteWidth = virtualWidth * 0.8f;
		float noteX = virtualWidth * 0.1f;
		float noteY = virtualHeight * 0.1f;

		float imageX = noteX + noteWidth - imageWidth + 80;
		float imageY = noteY - 80;

		Rect mapPiece = new Rect(imageX, imageY, imageWidth, imageHeight);
		Rect mapPieceShadow = new Rect(imageX+10, imageY+10, imageWidth, imageHeight);

		GUIManager.RotatedTexture(mapPieceShadow, mapPiece2Shadow, 2.0f, new Vector2(noteX + noteWidth, noteY));
		GUIManager.RotatedTexture(mapPiece, mapPiece2, 2.0f, new Vector2(noteX + noteWidth, noteY));
	}

	/// <summary>
	/// Draws map piece #3.
	/// </summary>
	public static void ThirdMapPiece()
	{
		float imageWidth = mapPiece1.width*0.4f;
		float imageHeight = mapPiece1.height*0.4f;

		float noteHeight = virtualHeight * 0.8f;
		float noteX = virtualWidth * 0.1f;
		float noteY = virtualHeight * 0.1f;

		float imageX = noteX - 80;
		float imageY = noteY + noteHeight - imageHeight + 80;

		Rect mapPiece = new Rect(imageX, imageY, imageWidth, imageHeight);
		Rect mapPieceShadow = new Rect(imageX+10, imageY+10, imageWidth, imageHeight);

		GUIManager.RotatedTexture(mapPieceShadow, mapPiece3Shadow, -3.0f, new Vector2(noteX, noteY + noteHeight));
		GUIManager.RotatedTexture(mapPiece, mapPiece3, -3.0f, new Vector2(noteX, noteY + noteHeight));
	}

	/// <summary>
	/// Draws map piece #4.
	/// </summary>
	public static void FourthMapPiece()
	{
		float imageWidth = mapPiece1.width*0.4f;
		float imageHeight = mapPiece1.height*0.4f;

		float noteWidth = virtualWidth * 0.8f;
		float noteHeight = virtualHeight * 0.8f;
		float noteX = virtualWidth * 0.1f;
		float noteY = virtualHeight * 0.1f;

		float imageX = noteX + noteWidth - imageWidth + 80;
		float imageY = noteY + noteHeight - imageHeight + 80;

		Rect mapPiece = new Rect(imageX, imageY, imageWidth, imageHeight);
		Rect mapPieceShadow = new Rect(imageX+10, imageY+10, imageWidth, imageHeight);

		GUIManager.RotatedTexture(mapPieceShadow, mapPiece4Shadow, 2.0f, new Vector2(noteX + noteWidth, noteY + noteHeight));
		GUIManager.RotatedTexture(mapPiece, mapPiece4, 2.0f, new Vector2(noteX + noteWidth, noteY + noteHeight));
	}

	#endregion

	#region GUIStyle setup code

	/// <summary>
	/// Initialize all GUI Styles.
	/// </summary>
	public static void Init()
	{
		GUI.skin.font = noteFont;

		titleStyle = new GUIStyle();
		titleStyle.fontSize = 150;
		titleStyle.fontStyle = FontStyle.Bold;
		titleStyle.normal.textColor = Color.black;
		titleStyle.alignment = TextAnchor.MiddleCenter;

		headerStyle = new GUIStyle();
		headerStyle.fontSize = 100;
		headerStyle.fontStyle = FontStyle.Bold;
		headerStyle.normal.textColor = Color.black;
		headerStyle.alignment = TextAnchor.MiddleCenter;

		labelStyle = new GUIStyle();
		labelStyle.fontSize = 50;
		labelStyle.normal.textColor = Color.black;

		centeredLabelStyle = new GUIStyle();
		centeredLabelStyle.fontSize = 50;
		centeredLabelStyle.normal.textColor = Color.black;
		centeredLabelStyle.alignment = TextAnchor.MiddleCenter;

		boldLabelStyle = new GUIStyle();
		boldLabelStyle.fontSize = 60;
		boldLabelStyle.fontStyle = FontStyle.Bold;
		boldLabelStyle.normal.textColor = Color.black;

		multilineLabelStyle = new GUIStyle();
		multilineLabelStyle.fontSize = 50;
		multilineLabelStyle.normal.textColor = Color.black;
		multilineLabelStyle.wordWrap = true;

		boldMultilineLabelStyle = new GUIStyle();
		boldMultilineLabelStyle.fontSize = 50;
		boldMultilineLabelStyle.normal.textColor = Color.black;
		boldMultilineLabelStyle.wordWrap = true;
		boldMultilineLabelStyle.fontStyle = FontStyle.Bold;

		debugLabelStyle = new GUIStyle();
		debugLabelStyle.fontSize = 20;
		debugLabelStyle.normal.textColor = Color.white;

		largeCenteredLabelStyle = new GUIStyle();
		largeCenteredLabelStyle.fontSize = 80;
		largeCenteredLabelStyle.normal.textColor = Color.black;
		largeCenteredLabelStyle.wordWrap = true;
		largeCenteredLabelStyle.alignment = TextAnchor.MiddleCenter;

		noteGroup = new GUIStyle();
		noteGroup.normal.background = Resources.Load("Images/Backgrounds/Note") as Texture2D;

		rightRedButtonStyle = new GUIStyle("Button");
		rightRedButtonStyle.alignment = TextAnchor.MiddleCenter;
		rightRedButtonStyle.fontSize = 50;
		rightRedButtonStyle.fontStyle = FontStyle.Bold;
		rightRedButtonStyle.normal.textColor = Color.white;
		rightRedButtonStyle.normal.background = Resources.Load("Images/Buttons/RightRedRibbon") as Texture2D;
		rightRedButtonStyle.active.background = Resources.Load("Images/Buttons/RightRedRibbonHighlight") as Texture2D;
		rightRedButtonStyle.hover.background = Resources.Load("Images/Buttons/RightRedRibbonHighlight") as Texture2D;
		rightRedButtonStyle.border.left = 0;
		rightRedButtonStyle.border.right = 0;
		rightRedButtonStyle.border.top = 0;
		rightRedButtonStyle.border.bottom = 0;

		leftRedButtonStyle = new GUIStyle("Button");
		leftRedButtonStyle.alignment = TextAnchor.MiddleCenter;
		leftRedButtonStyle.fontSize = 50;
		leftRedButtonStyle.fontStyle = FontStyle.Bold;
		leftRedButtonStyle.normal.textColor = Color.white;
		leftRedButtonStyle.alignment = TextAnchor.MiddleLeft;
		leftRedButtonStyle.normal.background = Resources.Load("Images/Buttons/LeftRedRibbon") as Texture2D;
		leftRedButtonStyle.active.background = Resources.Load("Images/Buttons/LeftRedRibbonHighlight") as Texture2D;
		leftRedButtonStyle.hover.background = Resources.Load("Images/Buttons/LeftRedRibbonHighlight") as Texture2D;
		leftRedButtonStyle.border.left = 0;
		leftRedButtonStyle.border.right = 0;
		leftRedButtonStyle.border.top = 0;
		leftRedButtonStyle.border.bottom = 0;

		rightGreenButtonStyle = new GUIStyle("Button");
		rightGreenButtonStyle.alignment = TextAnchor.MiddleCenter;
		rightGreenButtonStyle.fontSize = 50;
		rightGreenButtonStyle.fontStyle = FontStyle.Bold;
		rightGreenButtonStyle.normal.textColor = Color.white;
		rightGreenButtonStyle.normal.background = Resources.Load("Images/Buttons/RightGreenRibbon") as Texture2D;
		rightGreenButtonStyle.active.background = Resources.Load("Images/Buttons/RightGreenRibbonHighlight") as Texture2D;
		rightGreenButtonStyle.hover.background = Resources.Load("Images/Buttons/RightGreenRibbonHighlight") as Texture2D;
		rightGreenButtonStyle.border.left = 0;
		rightGreenButtonStyle.border.right = 0;
		rightGreenButtonStyle.border.top = 0;
		rightGreenButtonStyle.border.bottom = 0;

		drawnButtonStyle = new GUIStyle("Button");
		drawnButtonStyle.alignment = TextAnchor.MiddleCenter;
		drawnButtonStyle.fontSize = 50;
		drawnButtonStyle.fontStyle = FontStyle.Bold;
		drawnButtonStyle.normal.textColor = Color.black;
		drawnButtonStyle.normal.background = Resources.Load("Images/Buttons/DrawnButton") as Texture2D;
		drawnButtonStyle.active.background = Resources.Load("Images/Buttons/DrawnButtonHighlight") as Texture2D;
		drawnButtonStyle.hover.background = Resources.Load("Images/Buttons/DrawnButtonHighlight") as Texture2D;
		drawnButtonStyle.border.left = 0;
		drawnButtonStyle.border.right = 0;
		drawnButtonStyle.border.top = 0;
		drawnButtonStyle.border.bottom = 0;
	}

	#endregion
}


text:
'''
File: learning.py
Date: July 2, 2014
Description: this script takes as a list of word pairs, as well as the
vector representations of those words, and sets up a regression problem
to learn the parameters in our composition function.
Usage: python learning.py wordVectorsIn ParametersOut < training_data
Update (August 22, 2014): modified the script to take into account modified
handling of PPDB training extraction.
'''

import sys, commands, string, getopt, cPickle, math
import numpy as np
import multiprocessing as mp
import sklearn.linear_model as regressor
from extract_training import *

'''
read in word representations from text file
'''
def readVecFile(filename, normalize):
    fh = open(filename, 'r')
    repDict = {}
    for line in fh:
        word = line.strip().split()[0]
        rep = np.array([float(i) for i in line.strip().split()[1:]])
        repDict[word] = np.divide(rep, np.linalg.norm(rep)) if normalize else rep
    return repDict

'''
from PPDB, add the training example if it meets certain criteria
'''
def addTrainingExample(wordVecs, filterDup, training_data, training_stats, key, output, input_left, input_right):
    training_pos = training_data[key] if key in training_data else []
    num_train = training_stats[key] if key in training_stats else [0,0]
    num_train[0] += 1
    if output in wordVecs and input_left in wordVecs and input_right in wordVecs:
        if filterDup:
            if input_left != output and input_right != output:
                training_pos.append((wordVecs[output], wordVecs[input_left], wordVecs[input_right]))
                num_train[1] += 1
            else:
                sys.stderr.write("Filtered example %s ||| %s because of redundancy\n"%(output, ' '.join([input_left, input_right])))
        else:
            training_pos.append((wordVecs[output], wordVecs[input_left], wordVecs[input_right]))
            num_train[1] += 1
        training_data[key] = training_pos
    else:
        sys.stderr.write("Could not find one of the following words in the vocabulary: %s, %s, or %s\n"%(output, input_left, input_right))

'''
function that goes through PPDB and assembles the training data by calling addTrainingExample and doing some pre and post-processing
'''
def createTraining(dbloc, wordVecs, filterDup):
    print "Extracting training examples directly from PPDB"
    extractor = TrainingExtractor(dbloc, "all")
    extractor.extract_examples()
    training_tuples = extractor.return_examples()
    training_data = {}
    training_stats = {}
    for key, one_phrase, many_phrase in training_tuples:
        input_left = many_phrase.split()[0]
        input_right = many_phrase.split()[1]
        addTrainingExample(wordVecs, filterDup, training_data, training_stats, key, one_phrase, input_left, input_right)
    for key in training_stats:
        print "POS Pair %s: out of %d training examples, valid input-output triples exist for %d examples"%(key, training_stats[key][0], training_stats[key][1])
    return training_data

def readTrainingFromFile(trainFile, wordVecs, filterDup):
    print "Reading training examples from file"
    training_data = {}
    training_stats = {}
    train_fh = open(trainFile, 'rb')
    for line in train_fh:
        elements = line.strip().split(' ||| ')
        key = elements[0]
        for triple in elements[1:]:
            assert len(triple.split()) == 3
            one_phrase, input_left, input_right = triple.split()
            addTrainingExample(wordVecs, filterDup, training_data, training_stats, key, one_phrase, input_left, input_right)
        print "Completed reading in examples for %s"%key
    train_fh.close()
    return training_data

'''
distributed implementation of multivariate regression by doing the elements/coordinates independently.
There is something to be lost by this in that R^2 is always less than the multivariate solution,
but this difference is usually minimal and we can take advantage of multiple cores.  Only works
for particular types of regressions: lasso, ridge, lars, and elastic
'''
def regressorParallel(data, labels, start, end, regStr, out_q):
    reg = None
    if regStr == "lasso":
        reg = regressor.LassoCV()
    elif regStr == "ridge":
        reg = regressor.RidgeCV()
    elif regStr == "lars":
        reg = regressor.LassoLarsCV(n_jobs=1)
    elif regStr == "elastic":
        reg = regressor.ElasticNetCV()
    coefficients = []
    for idx in range(start, end):
        reg.fit(data, labels[:,idx]) #what would happen if we passed in labels, not labels[:,idx]?
        print "Dimension %d Alpha selected: %.3g"%(idx, reg.alpha_) #use this for CV experiments
        R2 = reg.score(data, labels[:,idx])
        print "Dimension %d R^2 on data: %.3f"%(idx, R2)
        print "Dimension %d Number of non-zero values in coefficients: %d"%(idx, (reg.coef_ != 0).sum())
        coefficients.append((idx, R2, reg.coef_, reg.intercept_))
    out_q.put(coefficients)

'''
standard multivariate regression where it is done together
'''
def regressorMultivariate(data, labels, regStr):
    reg = None
    if regStr == "lasso":
        reg = regressor.LassoCV()
    elif regStr == "ridge":
        reg = regressor.RidgeCV()
    elif regStr == "lars":
        reg = regressor.LassoLarsCV(n_jobs=1)
    elif regStr == "elastic":
        reg = regressor.ElasticNetCV()
    reg.fit(data, labels)
    print "Multivariate Alpha selected: %.3g"%reg.alpha_
    R2 = reg.score(data, labels)
    print "Multivariate R^2 on data: %.3f"%R2
    print "Number of non-zero values in coefficients: %d"%((reg.coef_ != 0).sum())
    return (reg.coef_, reg.intercept_)

'''
experimental regression function where the prior is linguistically motivated, so
we impose some kind of structural sparsity to the parameter matrix.
Only works for concatenative models
'''
def regressorLinguisticPrior(X, y, pos_pair, alpha, dim):
    numExamples = X.shape[0]
    print pos_pair #make change: only do this for certain combinations
    X = np.concatenate((np.ones((numExamples,1)), X), axis=1)
    left_mat = np.zeros((dim, dim+1)) #+1 because of intercept
    right_mat = np.identity(dim)*alpha
    W_star = np.concatenate((left_mat, right_mat), axis=1) #vx(p+1) matrix
    #set b depending on what the POS pair is, otherwise can just always set it to the 'else' value
    b = np.dot(X.T, y) if pos_pair == "X X" or pos_pair == "NN NN" else np.dot(X.T, y) + W_star.T #pxv matrix
    A = np.dot(X.T, X) + alpha*np.identity(W_star.shape[1]) #(p+1)x(p+1) matrix
    W = np.linalg.solve(A, b) #result should be (p+1)xv matrix
    intercept = W[0,:]
    return (W[1:,:].T, intercept)

'''
wrapper function for learning parameters
'''
def learnParameters(training_data, pos_pair, numProc, diagonal, concat, reg, multivariate, alpha):
    numSamples = len(training_data)
    dim = len(training_data[0][0])
    P = dim if diagonal else dim * dim
    if concat:
        P = 2*dim
    print "Number of training examples: %d; Number of regression problems: %d; Number of covariates: %d"%(numSamples, dim, P)
    y = np.zeros((numSamples, dim))
    X = np.zeros((numSamples, P))
    for idx, triple in enumerate(training_data): #assemble the data in y and X
        y[idx,:] = triple[0].transpose()
        if concat:
            X[idx,:] = np.concatenate((triple[1], triple[2]), axis=1)
        elif diagonal:
            X[idx,:] = np.diagonal(np.outer(triple[1], triple[2]))
        else:
            X[idx,:] = np.hstack(np.outer(triple[1], triple[2]))
    print "Completed assembling training data into regression format.  Now starting regression."
    parameter = np.zeros((dim, dim, dim)) if not concat else np.zeros((dim, 2*dim))
    intercept = np.zeros((dim))
    if reg == "multitask" or alpha >= 0 or multivariate:
        if alpha >= 0:
            coeff, intercept = regressorLinguisticPrior(X, y, pos_pair, alpha, dim)
        elif reg == "multitask":
            lasso = regressor.MultiTaskLasso(alpha=5e-5)  #call multitask lasso directly here
            print "Fixing alpha to 5e-5"
            lasso.fit(X, y)
            print "Multitask R^2: %.3f"%(lasso.score(X, y))
            coeff = lasso.coef_
            intercept = lasso.intercept_
        else: #can only be multivariate
            coeff, intercept = regressorMultivariate(X, y, reg)
        for idx in range(0, dim): #re-assemble parameters in the right structure
            if concat:
                parameter[idx,:] = coeff[idx,:]
            else:
                parameter[idx,:,:] = coeff[idx,:].reshape((dim, dim)) if not diagonal else np.diag(coeff[idx,:])
    else: #for parallel/distributed estimation
        out_q = mp.Queue()
        procs = []
        chunksize = int(math.floor(dim / float(numProc)))
        for proc in range(numProc):
            end = dim if proc == numProc - 1 else (proc+1)*chunksize
            p = mp.Process(target=regressorParallel, args=(X, y, chunksize*proc, end, reg, out_q))
            procs.append(p)
            p.start()
        coefficients = []
        for proc in range(numProc):
            coefficients += out_q.get()
        for p in procs:
            p.join()
        avgR2 = 0
        for coeff_idx_tuple in coefficients:
            idx, R2, coeff, inter = coeff_idx_tuple
            avgR2 += R2
            if concat:
                parameter[idx, :] = coeff
            else:
                parameter[idx, :, :] = coeff.reshape((dim, dim)) if not diagonal else np.diag(coeff)
            intercept[idx] = inter
        print "Parameter estimation complete and tensor has been formed"
        print "Average R2 across the %d regression problems: %.3f"%(dim, avgR2/dim)
    return parameter, intercept

def main():
    (opts, args) = getopt.getopt(sys.argv[1:], 'cdfj:mnpP:r:')
    normalize = False
    diagonal = False
    filterDup = False
    concat = False
    ppdb = False
    reg = "lasso"
    jobs = 4
    alpha = -1
    multivariate = False
    for opt in opts:
        if opt[0] == '-n':
            normalize = True
        elif opt[0] == '-j':
            jobs = int(opt[1])
        elif opt[0] == '-d':
            diagonal = True
        elif opt[0] == '-f':
            filterDup = True
        elif opt[0] == '-r':
            reg = opt[1]
            if not (reg == "lasso" or reg == "ridge" or reg == "lars" or reg == "elastic" or reg == "multitask"):
                sys.stderr.write("Error: regressor option not recognized; defaulting to 'lasso'\n")
                reg = "lasso"
        elif opt[0] == '-c': #concat model instead of outer product-based model
            concat = True
        elif opt[0] == '-p': #extract examples straight from PPDB
            ppdb = True
        elif opt[0] == '-P': #prior
            alpha = int(opt[1])
        elif opt[0] == '-m': #multivariate version of whatever algorithm chosen in -r
            multivariate = True
            if reg == "multitask":
                sys.stderr.write("Note: can only do multivariate regression on lasso, ridge, lars, or elastic")
                sys.exit()
    if diagonal and concat:
        sys.stderr.write("Error: cannot have diagonal parametrization and concatenative model together; setting diagonalization to false\n")
        diagonal = False
    if alpha >= 0 and (reg != "ridge" or not concat):
        sys.stderr.write("Error: linguistic regularization only works for L-2 prior (ridge regression) and concatenative models; setting regularizer to ridge and turning concatenation on\n")
        concat = True
        reg = "ridge"

    wordVecs = readVecFile(args[0], normalize)
    training_data = createTraining(args[1], wordVecs, filterDup) if ppdb else readTrainingFromFile(args[1], wordVecs, filterDup)
    print "Regressor chosen: %s"%reg
    parameters = {}
    for pos_pair in training_data:
        parameters[pos_pair] = learnParameters(training_data[pos_pair], pos_pair, jobs, diagonal, concat, reg, multivariate, alpha)
        print "Completed parameter learning for POS pair %s"%pos_pair
    cPickle.dump(parameters, open(args[2], "wb"))

if __name__ == "__main__":
    main()


text:
class AddAgeGroupToPerformances < ActiveRecord::Migration
  def change
    add_column :performances, :age_group, :string
  end
end


text:
<md-dialog class="compose-dialog" aria-label="Product form">
    <form class="md-inline-form">
        <md-toolbar class="md-accent md-hue-2">

                Product Form
                <md-button class="md-icon-button" ng-click="vm.closeDialog()" aria-label="Close dialog">
                    <md-icon md-font-icon="icon-close"></md-icon>
                </md-button>

        </md-toolbar>

        <md-dialog-content ms-scroll>
            <md-input-container class="md-block">
                Name
                <input ng-model="vm.product.name" type="text">
            </md-input-container>

            <md-input-container class="md-block">
                Type
                <input ng-model="vm.product.type" type="text">
            </md-input-container>

            <md-input-container class="md-block">
                Calories
                <input ng-model="vm.product.calories.value" type="number">
            </md-input-container>

            <md-input-container class="md-block">
                Sodium
                <input ng-model="vm.product.sodium.value" type="number">
            </md-input-container>
        </md-dialog-content>

        <md-dialog-actions layout="row" layout-align="space-between center">

                <md-button ng-click="vm.saveDialog()" class="send-button md-accent md-raised" aria-label="Save">
                    SAVE
                </md-button>

                <md-button ng-click="vm.cancelDialog()" class="send-button md-accent md-raised" aria-label="Cancel">
                    CANCEL
                </md-button>

        </md-dialog-actions>
    </form>
</md-dialog>


text:
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_9" default="false" project-jdk-name="16" project-jdk-type="JavaSDK">
    <output url="file://$PROJECT_DIR$/.idea/out" />
  </component>
</project>