text:
using System;
using System.Linq;
using System.Windows.Forms;

using BizHawk.Client.Common;
using NLua;

namespace BizHawk.Client.EmuHawk
{
	public sealed class InputLuaLibrary : LuaLibraryBase
	{
		public InputLuaLibrary(Lua lua)
			: base(lua) { }

		public InputLuaLibrary(Lua lua, Action<string> logOutputCallback)
			: base(lua, logOutputCallback) { }

		public override string Name => "input";

		[LuaMethodExample("local nlinpget = input.get( );")]
		[LuaMethod("get", "Returns a lua table of all the buttons the user is currently pressing on their keyboard and gamepads\nAll buttons that are pressed have their key values set to true; all others remain nil.")]
		public LuaTable Get()
		{
			var buttons = Lua.NewTable();
			foreach (var kvp in Global.ControllerInputCoalescer.BoolButtons().Where(kvp => kvp.Value))
			{
				buttons[kvp.Key] = true;
			}

			return buttons;
		}

		[LuaMethodExample("local nlinpget = input.getmouse( );")]
		[LuaMethod("getmouse", "Returns a lua table of the mouse X/Y coordinates and button states. Table keys are X, Y, Left, Middle, Right, XButton1, XButton2, Wheel.")]
		public LuaTable GetMouse()
		{
			var buttons = Lua.NewTable();

			// TODO - need to specify whether in "emu" or "native" coordinate space.
			var p = GlobalWin.DisplayManager.UntransformPoint(Control.MousePosition);
			buttons["X"] = p.X;
			buttons["Y"] = p.Y;
			buttons[MouseButtons.Left.ToString()] = (Control.MouseButtons & MouseButtons.Left) != 0;
			buttons[MouseButtons.Middle.ToString()] = (Control.MouseButtons & MouseButtons.Middle) != 0;
			buttons[MouseButtons.Right.ToString()] = (Control.MouseButtons & MouseButtons.Right) != 0;
			buttons[MouseButtons.XButton1.ToString()] = (Control.MouseButtons & MouseButtons.XButton1) != 0;
			buttons[MouseButtons.XButton2.ToString()] = (Control.MouseButtons & MouseButtons.XButton2) != 0;
			buttons["Wheel"] = GlobalWin.MainForm.MouseWheelTracker;
			return buttons;
		}
	}
}


text:
from optparse import OptionParser
from collections import namedtuple

# Options holds the command line options
Options = namedtuple("Options", "KafkaHost KafkaTopic")

# Parses the command line options
def parse_commandline():
    parser = OptionParser(usage='%prog [options] <Excel File>')

    parser.add_option('-k', '--kafka-host',
                      dest="kafka_host",
                      default="localhost:9092",
                      help="Hostname (and port) of the Kafka data backbone server."
                      )

    parser.add_option('-t', '--kafka-topic',
                      dest="kafka_topic",
                      default="soma",
                      help="The topic name under which messages are broadcasted to Kafka."
                      )

    options, remainder = parser.parse_args()

    # if len(remainder) != 1:
    #     parser.print_help()
    #     raise Exception("Wrong numer of arguments")

    return Options(
        KafkaHost=options.kafka_host,
        KafkaTopic=options.kafka_topic
    )

redpajama_set_name: RedPajamaGithub


text:
<?php
namespace Craft;

class Redirect_Node extends \Twig_Node
{
	// Public Methods
	// =========================================================================

	/**
	 * Compiles a Redirect_Node into PHP.
	 *
	 * @param \Twig_Compiler $compiler
	 *
	 * @return null
	 */
	public function compile(\Twig_Compiler $compiler)
	{
		$compiler
		    ->addDebugInfo($this)
		    ->write('\Craft\craft()->request->redirect(\Craft\UrlHelper::getUrl(')
		    ->subcompile($this->getNode('path'))
		    ->raw("), true, ")
		    ->subcompile($this->getNode('httpStatusCode'))
		    ->raw(");\n");
	}
}


text:
// **********************************************************************************
// The MIT License (MIT)
//
// Copyright (c) 2014 Rob Prouse
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// **********************************************************************************

#region Using Directives

using System;
using Alteridem.GitHub.Model;
using NUnit.Framework;

#endregion

namespace Alteridem.GitHub.Extension.Test.Model
{
    [TestFixture]
    public class CredentialCacheTest
    {
        [Test]
        public void TestRoundTrip()
        {
            var credentials = new CredentialCache { Logon = "user", Password = "password", AccessToken = string.Empty };
            var cache = credentials.ToString();
            Assert.That(cache, Is.Not.Null);
            Assert.That(cache, Does.Contain("user"));
            Assert.That(cache, Does.Not.Contain("password"));

            var parsed = CredentialCache.FromString(cache);
            Assert.That(parsed, Is.Not.Null);
            Assert.That(parsed.Logon, Is.EqualTo("user"));
            Assert.That(parsed.Password, Is.EqualTo("password"));
            Assert.That(parsed.AccessToken, Is.EqualTo(string.Empty));
        }

        [Test]
        public void FromNullStringReturnsNull()
        {
            Assert.That(CredentialCache.FromString(null), Is.Null);
        }

        [Test]
        public void FromEmptyStringReturnsNull()
        {
            Assert.That(CredentialCache.FromString(string.Empty), Is.Null);
        }

        [Test]
        public void FromBlankStringReturnsNull()
        {
            Assert.That(CredentialCache.FromString("   "), Is.Null);
        }
    }
}


text:
using System.Collections.Generic;
using System.Linq;
using System.Management.Automation;
using System.Xml;
using Sitecore.Configuration;
using Sitecore.Data.Serialization.Presets;

namespace Cognifide.PowerShell.Commandlets.Serialization
{
    [Cmdlet(VerbsCommon.Get, "Preset")]
    [OutputType(typeof (IncludeEntry))]
    public class GetPresetCommand : BaseCommand
    {
        [Parameter(Position = 0, Mandatory = false)]
        public string[] Name { get; set; }

        protected override void ProcessRecord()
        {
            //WriteObject(GetPresetItems(Name), true);

            var presetsNode = Factory.GetConfigNode("serialization");
            if (presetsNode == null)
            {
                return;
            }

            var allPresets = presetsNode.Cast<XmlNode>().ToList();

            if (Name != null && Name.Length > 0)
            {
                var matchingPresets = WildcardFilterMany(Name, allPresets, p => p.Name).ToList();
                WriteObject(matchingPresets.SelectMany(CreatePreset), true);
            }
            else
            {
                WriteObject(allPresets.SelectMany(CreatePreset), true);
            }
        }

        private static IEnumerable<PSObject> CreatePreset(XmlNode presetNode)
        {
            var presetEntries = PresetFactory.Create(presetNode);
            return presetEntries.Select(preset =>
            {
                var psPreset = PSObject.AsPSObject(preset);
                psPreset.Properties.Add(new PSNoteProperty("PresetName", presetNode.Name));
                return psPreset;
            });
        }
    }
}


text:
if [[ $EUID -ne 0 ]]; then
	echo -e "Sorry, you need to run this as root"
	exit 1
fi

NGINX_VER=1.23.1
# Define options
NGINX_OPTIONS=${NGINX_OPTIONS:-"
	--prefix=/etc/nginx \
	--sbin-path=/usr/sbin/nginx \
	--conf-path=/etc/nginx/nginx.conf \
	--error-log-path=/var/log/nginx/error.log \
	--http-log-path=/var/log/nginx/access.log \
	--pid-path=/var/run/nginx.pid \
	--lock-path=/var/run/nginx.lock \
	--http-client-body-temp-path=/var/cache/nginx/client_temp \
	--http-proxy-temp-path=/var/cache/nginx/proxy_temp \
	--http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp \
	--user=nginx \
	--group=nginx \
	--with-cc-opt=-Wno-deprecated-declarations \
	--with-cc-opt=-Wno-ignored-qualifiers"}
# Define modules
NGINX_MODULES=${NGINX_MODULES:-"--with-threads \
	--with-file-aio \
	--with-http_ssl_module \
	--with-http_v2_module \
	--with-http_mp4_module \
	--with-http_auth_request_module \
	--with-http_slice_module \
	--with-http_stub_status_module \
	--with-http_realip_module \
	--with-http_sub_module"}

if [[ $HEADLESS != "y" ]]; then
	echo ""
	echo "Welcome to the nginx-autoinstall script."
	echo ""
	echo "What do you want to do?"
	echo "   1) Install or update Nginx"
	echo "   2) Uninstall Nginx"
	echo "   3) Exit"
	echo ""
	while [[ $OPTION != "1" && $OPTION != "2" && $OPTION != "3" && $OPTION != "4" && $OPTION != "5" ]]; do
		read -rp "Select an option [1-3]: " OPTION
	done
fi

case $OPTION in
1)
  # Cleanup
	# The directory should be deleted at the end of the script, but in case it fails
	rm -r /usr/local/src/nginx/ >>/dev/null 2>&1
	mkdir -p /usr/local/src/nginx/modules

  # Dependencies
	apt-get update
	apt-get install -y build-essential ca-certificates wget curl libpcre3 libpcre3-dev autoconf unzip automake libtool tar git libssl-dev zlib1g-dev uuid-dev lsb-release libxml2-dev libxslt1-dev cmake

  # Download and extract of Nginx source code
	cd /usr/local/src/nginx/ || exit 1
	wget -qO- http://nginx.org/download/nginx-${NGINX_VER}.tar.gz | tar zxf -
  # curl https://nginx.org/download/nginx-$NGINX_VER.tar.gz | tar -zx
	cd nginx-${NGINX_VER} || exit 1

  # As the default nginx.conf does not work, we download a clean and working conf from my GitHub.
	# We do it only if it does not already exist, so that it is not overriten if Nginx is being updated
	if [[ ! -e /etc/nginx/nginx.conf ]]; then
		mkdir -p /etc/nginx
		cd /etc/nginx || exit 1
	fi

	cd /usr/local/src/nginx/nginx-${NGINX_VER} || exit 1

  	./configure $NGINX_OPTIONS $NGINX_MODULES
	make -j "$(nproc)"
	make install

  # remove debugging symbols
	strip -s /usr/sbin/nginx

  # Nginx installation from source does not add an init script for systemd and logrotate
	# Using the official systemd script and logrotate conf from nginx.org
	if [[ ! -e /lib/systemd/system/nginx.service ]]; then
		cd /lib/systemd/system/ || exit 1
    cat << EOF > nginx.service
# Stop dance for nginx
# =======================
#
# ExecStop sends SIGSTOP (graceful stop) to the nginx process.
# If, after 5s (--retry QUIT/5) nginx is still running, systemd takes control
# and sends SIGTERM (fast shutdown) to the main process.
# After another 5s (TimeoutStopSec=5), and if nginx is alive, systemd sends
# SIGKILL to all the remaining processes in the process group (KillMode=mixed).
#
# nginx signals reference doc:
# http://nginx.org/en/docs/control.html
#
[Unit]
Description=A high performance web server and a reverse proxy server
After=network.target nss-lookup.target

[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t -q -g 'daemon on; master_process on;'
ExecStart=/usr/sbin/nginx -g 'daemon on; master_process on;'
# See https://github.com/angristan/nginx-autoinstall/issues/67
ExecStartPost=/bin/sleep 0.1
ExecReload=/usr/sbin/nginx -g 'daemon on; master_process on;' -s reload
ExecStop=-/sbin/start-stop-daemon --quiet --stop --retry QUIT/5 --pidfile /run/nginx.pid
TimeoutStopSec=5
KillMode=mixed

[Install]
WantedBy=multi-user.target
EOF

		# Enable nginx start at boot
		systemctl enable nginx
	fi

  # Nginx's cache directory is not created by default
	if [[ ! -d /var/cache/nginx ]]; then
		mkdir -p /var/cache/nginx
	fi

  if [[ ! -d /etc/nginx/conf.d ]]; then
		mkdir -p /etc/nginx/conf.d
	fi

  # Removing temporary Nginx and modules files
	rm -r /usr/local/src/nginx

  # We're done !
	echo "Installation done."
	exit

  ;;
2) # Uninstall nginx
  # We're done !
	echo "Uninstallation done."
  # Stop Nginx
	systemctl stop nginx

	# Removing Nginx files and modules files
	rm -r /usr/local/src/nginx \
		/usr/sbin/nginx* \
		/usr/local/bin/luajit* \
		/usr/local/include/luajit* \
		/etc/logrotate.d/nginx \
		/var/cache/nginx \
		/lib/systemd/system/nginx.service \
		/etc/systemd/system/multi-user.target.wants/nginx.service

	# Reload systemctl
	systemctl daemon-reload

	exit
  ;;
*)
  exit
  ;;
esac


text:
Material Design Preloader!s
=============

A jQuery plugin that recreates the Material Design preloader (as seen on inbox).

[View Demo](http://git.aaronlumsden.com/material/)

![materialPreloader.js](http://i60.tinypic.com/mj60lw.jpg)

I was fascinated when I first saw the preloader for Google's inbox website so I thought I'd recreate it and turn it into a plugin so that others can use it in their app or website.

### How to use

Make sure you have jQuery included and include 'materialPreloader.js' after jQuery.

```js
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
<script type="text/javascript" src="materialPreloader.js"></script>

```

You also need to include 'materialPreloader.css'.

```css
<link rel="stylesheet" type="text/css" href="css/materialPreloader.css">
```

You can then instantiate the plugin along with its options (if required).

```js
<script type="text/javascript">

 preloader = new $.materialPreloader({
        position: 'top',
        height: '5px',
        col_1: '#159756',
        col_2: '#da4733',
        col_3: '#3b78e7',
        col_4: '#fdba2c',
        fadeIn: 200,
        fadeOut: 200
    });

</script>
```

You can then call the following functions to turn the preloader on & off

```js
 preloader.on();
 preloader.off();
```

### materialPreloader Options

| Option        | Required           | Description						| Options	  | Default 	|
| ------------- |--------------------|----------------------------------|-------------|-------------|
| position	    | No		 		 | 	Position to place the preloader	| top/bottom  |	bottom   	|
| height      	| No      	 		 | 	The height of the preloader bar	| any length  |	5px   		|
| col_1      	| No      	 		 |  Color 1 option					| any color   |	#159756   	|
| col_2      	| No      	 		 | 	Color 2 option			 		| any color   |	#da4733   	|
| col_3      	| No      	 		 |  Color 3 option					| any color   |	#3b78e7  	|
| col_4      	| No      	 		 | 	Color 4 option					| any color   |	#fdba2c  	|
| fadeIn      	| No      	 		 |  Speed in milliseconds 			| any speed   |	200   		|
| fadeOut      	| No      	 		 |  Speed in milliseconds			| any speed	  |	200   		|

## Browser Support

 - Chrome
 - Safari
 - Firefox
 - Not tested in IE


text:
cask "actual" do
  arch arm: "-arm64"

  version "0.0.148"

  on_intel do
    sha256 "95159e54c011aba02f64b0d126a497b99544e1086429a11e67587e3ffc0533d4"
  end
  on_arm do
    sha256 "df9e2139a3a5b1355f1ed1a28863115ac574eb15ec856d6e95de13b02bc26ae0"
  end

  url "https://github.com/actualbudget/releases/releases/download/#{version}/Actual-#{version}#{arch}.dmg",
      verified: "github.com/actualbudget/releases/"
  name "Actual"
  desc "Privacy-focused app for managing your finances"
  homepage "https://actualbudget.com/"

  app "Actual.app"

  zap trash: [
    "~/Documents/Actual",
    "~/Library/Application Support/Actual",
    "~/Library/Logs/Actual",
    "~/Library/Preferences/com.shiftreset.actual.plist",
    "~/Library/Saved Application State/com.shiftreset.actual.savedState",
  ]
end


text:
var join = require('path').join;
var execFileSync = require('child_process').execFileSync;
var cache = {};
var originalWhich = require('which');

var isWin = process.platform === 'win32';

function which(name, opt, cb) {
    if (typeof opt === 'function') {
        cb = opt;
        opt = {};
    }

    if (isWin) {
        var result = whichSync(name);
        if (result) {
            cb(null, result);
        } else {
            cb(new Error('Could not find ' + name + ' in PATH'));
        }
    } else {
        originalWhich(name, opt, cb);
    }
}

function whichSync(name, opt) {
    if (name in cache) {
        return cache[name];
    }
    if (isWin) {
        var WHERE_PATH = join(process.env.WINDIR, 'System32', 'where.exe');
        var stdout = execFileSync(WHERE_PATH, ['$PATH:' + name], {
            stdio: ['pipe', 'pipe', 'ignore']
        }).toString();
        var matches = stdout.split('\r\n');
        if (matches.length === 0) {
            throw new Error('Could not find ' + name + ' in PATH');
        }
        var result = matches[0].trim();
        cache[name] = result;
        return result;
    }

    var result = originalWhich.sync(name, opt);
    cache[name] = result;
    return result;
}

which.sync = whichSync;

module.exports = which;


text:
using System;
using System.Linq;
using System.Linq.Expressions;
using System.Threading;
using System.Threading.Tasks;
using Baseline;
using Marten.Linq;

namespace Marten
{
    public static class CompiledQueryExtensions
    {
        public static string AsJson<T>(this T target)
        {
            throw new NotSupportedException();
        }

        public static IQueryable<string> AsJson<T>(this IMartenQueryable<T> queryable)
        {
            return queryable.Select(x => x.AsJson());
        }

        public static IQueryable<string> AsJson<T>(this IQueryable<T> queryable)
        {
            return queryable.Select(x => x.AsJson());
        }

        public static IQueryable<string> AsJson<T>(this IOrderedQueryable<T> queryable)
        {
            return queryable.Select(x => x.AsJson());
        }

        public static string ToJsonArray<T>(this IQueryable<T> queryable)
        {
            return queryable.As<IMartenQueryable<T>>().ToJsonArray();
        }

        public static string ToJsonArray<T>(this IOrderedQueryable<T> queryable)
        {
            return queryable.As<IMartenQueryable<T>>().ToJsonArray();
        }

        public static Task<string> ToJsonArrayAsync<T>(this IQueryable<T> queryable, CancellationToken token = default)
        {
            return queryable.As<IMartenQueryable<T>>().ToJsonArrayAsync(token);
        }
    }
}


text:
/*
 * PdxRemoteReader.cpp
 *
 *  Created on: Nov 3, 2011
 *      Author: npatel
 */

#include "PdxRemoteReader.hpp"
#include "PdxTypes.hpp"

namespace apache {
namespace geode {
namespace client {

PdxRemoteReader::~PdxRemoteReader() {
  // TODO Auto-generated destructor stub
}

char16_t PdxRemoteReader::readChar(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2:
      return PdxLocalReader::readChar(fieldName);  // in same order
    case -1: {
      return '\0';  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      auto retVal = PdxLocalReader::readChar(fieldName);
      PdxLocalReader::resettoPdxHead();
      return retVal;
    }
  }
}

bool PdxRemoteReader::readBoolean(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readBoolean(fieldName);  // in same order
    }
    case -1: {
      return 0;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        bool retVal = PdxLocalReader::readBoolean(fieldName);
        PdxLocalReader::resettoPdxHead();
        return retVal;
      } else {
        return 0;  // null value
      }
    }
  }
}

int8_t PdxRemoteReader::readByte(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readByte(fieldName);  // in same order
    }
    case -1: {
      return 0;
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        int8_t retValue;
        retValue = PdxLocalReader::readByte(fieldName);
        PdxLocalReader::resettoPdxHead();
        return retValue;
      } else {
        return 0;  // null value
      }
    }
  }
}

int16_t PdxRemoteReader::readShort(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readShort(fieldName);  // in same order
    }
    case -1: {
      return 0;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        int16_t value;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        value = PdxLocalReader::readShort(fieldName);
        PdxLocalReader::resettoPdxHead();
        return value;
      } else {
        return 0;  // null value
      }
    }
  }
}

int32_t PdxRemoteReader::readInt(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readInt(fieldName);  // in same order
    }
    case -1: {
      return 0;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        int32_t value;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        value = PdxLocalReader::readInt(fieldName);
        PdxLocalReader::resettoPdxHead();
        return value;
      } else {
        return 0;  // null value
      }
    }
  }
}

int64_t PdxRemoteReader::readLong(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readLong(fieldName);  // in same order
    }
    case -1: {
      return 0;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        int64_t value;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        value = PdxLocalReader::readLong(fieldName);
        PdxLocalReader::resettoPdxHead();
        return value;
      } else {
        return 0;  // null value
      }
    }
  }
}

float PdxRemoteReader::readFloat(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readFloat(fieldName);  // in same order
    }
    case -1: {
      return 0.0f;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        float value;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        value = PdxLocalReader::readFloat(fieldName);
        PdxLocalReader::resettoPdxHead();
        return value;
      } else {
        return 0.0f;  // null value
      }
    }
  }
}

double PdxRemoteReader::readDouble(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readDouble(fieldName);  // in same order
    }
    case -1: {
      return 0.0;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        double value;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        value = PdxLocalReader::readDouble(fieldName);
        PdxLocalReader::resettoPdxHead();
        return value;
      } else {
        return 0.0;  // null value
      }
    }
  }
}

std::string PdxRemoteReader::readString(const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readString(fieldName);
    }
    case -1: {
      return std::string();
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        auto retVal = PdxLocalReader::readString(fieldName);
        PdxLocalReader::resettoPdxHead();
        return retVal;
      } else {
        static std::string emptyString;
        return emptyString;
      }
    }
  }
}

std::shared_ptr<Serializable> PdxRemoteReader::readObject(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readObject(fieldName);  // in same order
    }
    case -1: {
      return nullptr;
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        std::shared_ptr<Serializable> ptr;
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        ptr = PdxLocalReader::readObject(fieldName);
        PdxLocalReader::resettoPdxHead();
        return ptr;
      } else {
        return nullptr;  // null value
      }
    }
  }
}

std::vector<char16_t> PdxRemoteReader::readCharArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<char16_t> array;
  switch (choice) {
    case -2:
      array = PdxLocalReader::readCharArray(fieldName);  // in same order
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      array = PdxLocalReader::readCharArray(fieldName);
      PdxLocalReader::resettoPdxHead();
    }
  }
  return array;
}

std::vector<bool> PdxRemoteReader::readBooleanArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<bool> array;
  switch (choice) {
    case -2:
      array = PdxLocalReader::readBooleanArray(fieldName);  // in same order
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      array = PdxLocalReader::readBooleanArray(fieldName);
      PdxLocalReader::resettoPdxHead();
    }
  }
  return array;
}

std::vector<int8_t> PdxRemoteReader::readByteArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<int8_t> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readByteArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readByteArray(fieldName);
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<int16_t> PdxRemoteReader::readShortArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<int16_t> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readShortArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readShortArray(fieldName);
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<int32_t> PdxRemoteReader::readIntArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<int32_t> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readIntArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readIntArray(fieldName);
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<int64_t> PdxRemoteReader::readLongArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<int64_t> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readLongArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readLongArray(fieldName);
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<float> PdxRemoteReader::readFloatArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<float> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readFloatArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readFloatArray(fieldName);  // in same order
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<double> PdxRemoteReader::readDoubleArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  std::vector<double> array;
  switch (choice) {
    case -2: {
      array = PdxLocalReader::readDoubleArray(fieldName);  // in same order
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        array = PdxLocalReader::readDoubleArray(fieldName);  // in same order
        PdxLocalReader::resettoPdxHead();
      }
    }
  }
  return array;
}

std::vector<std::string> PdxRemoteReader::readStringArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2: {
      return PdxLocalReader::readStringArray(fieldName);
    }
    case -1: {
      return std::vector<std::string>();
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      if (position != -1) {
        PdxLocalReader::resettoPdxHead();
        m_dataInput->advanceCursor(position);
        auto strArray = PdxLocalReader::readStringArray(fieldName);
        PdxLocalReader::resettoPdxHead();
        return strArray;
      } else {
        return std::vector<std::string>();
      }
    }
  }
}

std::shared_ptr<CacheableObjectArray> PdxRemoteReader::readObjectArray(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2:
      return PdxLocalReader::readObjectArray(fieldName);  // in same order
    case -1: {
      return nullptr;  // null value
    }
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      auto retVal = PdxLocalReader::readObjectArray(fieldName);
      PdxLocalReader::resettoPdxHead();
      return retVal;
    }
  }
}

int8_t** PdxRemoteReader::readArrayOfByteArrays(const std::string& fieldName,
                                                int32_t& arrayLength,
                                                int32_t** elementLength) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2:
      return PdxLocalReader::readArrayOfByteArrays(
          fieldName, arrayLength, elementLength);  // in same order
    case -1:
      return nullptr;  // null value
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      int8_t** retVal = PdxLocalReader::readArrayOfByteArrays(
          fieldName, arrayLength, elementLength);
      PdxLocalReader::resettoPdxHead();
      return retVal;
    }
  }
}

std::shared_ptr<CacheableDate> PdxRemoteReader::readDate(
    const std::string& fieldName) {
  int choice = m_localToRemoteMap[m_currentIndex++];

  switch (choice) {
    case -2:
      return PdxLocalReader::readDate(fieldName);  // in same order
    case -1:
      return nullptr;
    default: {
      // sequence id read field and then update
      int position = m_pdxType->getFieldPosition(
          choice, m_offsetsBuffer, m_offsetSize, m_serializedLength);
      PdxLocalReader::resettoPdxHead();
      m_dataInput->advanceCursor(position);
      auto retVal = PdxLocalReader::readDate(fieldName);
      PdxLocalReader::resettoPdxHead();
      return retVal;
    }
  }
}

}  // namespace client
}  // namespace geode
}  // namespace apache


text:
namespace UiMetadataFramework.Core.Binding
{
	using System;

	/// <summary>
	/// Thrown when form's metadata is configured incorrectly.
	/// </summary>
	public class BindingException : Exception
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="BindingException"/> class.
		/// </summary>
		/// <param name="message"></param>
		public BindingException(string message)
			: base(message)
		{
		}
	}
}


text:
package validate

import (
	"reflect"
	"regexp"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/spec"
	"github.com/go-openapi/strfmt"
)

type objectValidator struct {
	Path                 string
	In                   string
	MaxProperties        *int64
	MinProperties        *int64
	Required             []string
	Properties           map[string]spec.Schema
	AdditionalProperties *spec.SchemaOrBool
	PatternProperties    map[string]spec.Schema
	Root                 interface{}
	KnownFormats         strfmt.Registry
}

func (o *objectValidator) SetPath(path string) {
	o.Path = path
}

func (o *objectValidator) Applies(source interface{}, kind reflect.Kind) bool {
	// TODO: this should also work for structs
	// there is a problem in the type validator where it will be unhappy about null values
	// so that requires more testing
	r := reflect.TypeOf(source) == specSchemaType && (kind == reflect.Map || kind == reflect.Struct)
	// fmt.Printf("object validator for %q applies %t for %T (kind: %v)\n", o.Path, r, source, kind)
	return r
}

func (o *objectValidator) Validate(data interface{}) *Result {
	val := data.(map[string]interface{})
	numKeys := int64(len(val))

	if o.MinProperties != nil && numKeys < *o.MinProperties {
		return sErr(errors.TooFewProperties(o.Path, o.In, *o.MinProperties))
	}
	if o.MaxProperties != nil && numKeys > *o.MaxProperties {
		return sErr(errors.TooManyProperties(o.Path, o.In, *o.MaxProperties))
	}

	res := new(Result)
	if len(o.Required) > 0 {
		for _, k := range o.Required {
			if _, ok := val[k]; !ok {
				res.AddErrors(errors.Required(o.Path+"."+k, o.In))
				continue
			}
		}
	}

	if o.AdditionalProperties != nil && !o.AdditionalProperties.Allows {
		for k := range val {
			_, regularProperty := o.Properties[k]
			matched := false

			for pk := range o.PatternProperties {
				if matches, _ := regexp.MatchString(pk, k); matches {
					matched = true
					break
				}
			}
			if !regularProperty && k != "$schema" && k != "id" && !matched {
				res.AddErrors(errors.PropertyNotAllowed(o.Path, o.In, k))
			}
		}
	} else {
		for key, value := range val {
			_, regularProperty := o.Properties[key]
			matched, succeededOnce, _ := o.validatePatternProperty(key, value, res)
			if !(regularProperty || matched || succeededOnce) {
				if o.AdditionalProperties != nil && o.AdditionalProperties.Schema != nil {
					res.Merge(NewSchemaValidator(o.AdditionalProperties.Schema, o.Root, o.Path+"."+key, o.KnownFormats).Validate(value))
				} else if regularProperty && !(matched || succeededOnce) {
					res.AddErrors(errors.FailedAllPatternProperties(o.Path, o.In, key))
				}
			}
		}
	}

	for pName, pSchema := range o.Properties {
		rName := pName
		if o.Path != "" {
			rName = o.Path + "." + pName
		}

		if v, ok := val[pName]; ok {
			res.Merge(NewSchemaValidator(&pSchema, o.Root, rName, o.KnownFormats).Validate(v))
		}
	}

	for key, value := range val {
		_, regularProperty := o.Properties[key]
		matched, succeededOnce, patterns := o.validatePatternProperty(key, value, res)
		if !regularProperty && (matched || succeededOnce) {
			for _, pName := range patterns {
				if v, ok := o.PatternProperties[pName]; ok {
					res.Merge(NewSchemaValidator(&v, o.Root, o.Path+"."+key, o.KnownFormats).Validate(value))
				}
			}
		}
	}
	return res
}

func (o *objectValidator) validatePatternProperty(key string, value interface{}, result *Result) (bool, bool, []string) {
	matched := false
	succeededOnce := false
	var patterns []string

	for k, schema := range o.PatternProperties {
		if match, _ := regexp.MatchString(k, key); match {
			patterns = append(patterns, k)
			matched = true
			validator := NewSchemaValidator(&schema, o.Root, o.Path+"."+key, o.KnownFormats)

			res := validator.Validate(value)
			result.Merge(res)
			if res.IsValid() {
				succeededOnce = true
			}
		}
	}

	if succeededOnce {
		result.Inc()
	}

	return matched, succeededOnce, patterns
}


text:
'use strict';

const mongoose = require('mongoose');
const Joi = require('joi');
const Joigoose = require('joigoose')(mongoose);
const _ = require('lodash');

let schema = Joi.object({
    title: Joi.string().required().min(3).max(128).meta({ index: true }),
    details: Joi.string().max(2048),
    pilots: Joi.array().items(Joi.string()).required(),
    tags: Joi.array().items(Joi.string().min(2).max(25).meta({ lowercase: true, index: true })),
    theater: Joi.string().required().max(128),
    missionType: Joi.string().required().max(64),
    videoUrl: Joi.string().max(512).allow(''),
    files: Joi.array().items(Joi.object({
        file: Joi.string(),
        key: Joi.string(),
        bucket: Joi.string()
    }).meta({ _id: false })).required(),
    slug: Joi.string().required().meta({ index: true }),
    uploadedAt: Joi.date().default(() => Date.now(), 'Defaults to the current time'),
    uploadedBy: Joi.string().meta({ type: 'ObjectId', ref: 'Pilot' })
});

let model = mongoose.model('Acmi', Joigoose.convert(schema), 'acmis');
model.validationSchema = _.omit(schema, ['slug', 'uploadedBy', 'uploadedAt' ]);
module.exports = model;


text:
import { expect } from 'chai'
import composeMiddleware from '../../../src/utils/compose-middleware'

describe('compose middleware', () => {
  describe('with no middleware', () => {
    it('should fail if a non-array supplied', () => {
      expect(() => composeMiddleware(null)).to.throw(TypeError, 'Stack must be an array')
    })

    it('should fail if the array contains non-function values', () => {
      const middleware = [ 'hello', 'world' ]
      expect(() => composeMiddleware(middleware)).to.throw(TypeError, 'Middleware must be composed of functions')
    })

    it('should resolve an empty promise when supplied an empty array', () => {
      return composeMiddleware([])()
    })
  })

  describe('with multiple middleware applied', () => {
    it('execute them with the supplied parameters', () => {
      let executionCount = 0

      const middlewareA = (req, res, done) => {
        req.should.equal('hello')
        res.should.equal('world')
        executionCount++
        done()
      }

      const middlewareB = (req, res, done) => {
        req.should.equal('hello')
        res.should.equal('world')
        executionCount++
        done()
      }

      const middleware = [ middlewareA, middlewareB ]

      return composeMiddleware(middleware)('hello', 'world')
        .then(() => {
          executionCount.should.equal(2)
        })
    })

    it('should reject the promise if middleware throws an error', () => {
      const middlewareA = (req, res, done) => {
        req.should.equal('hello')
        res.should.equal('world')
        throw new Error('test-error')
      }

      const middleware = [ middlewareA ]

      return composeMiddleware(middleware)('hello', 'world')
        .then(() => {
          throw new Error('Test expected to fail')
        })
        .catch(err => {
          err.message.should.equal('test-error')
        })
    })
  })
})


text:
#include "WireFormatFactory.h"

using namespace activemq;
using namespace activemq::wireformat;

////////////////////////////////////////////////////////////////////////////////
WireFormatFactory::~WireFormatFactory() {}


text:
import React from 'react'
import { IndexLink, Link } from 'react-router'
import PropTypes from 'prop-types'
import './PageLayout.scss'

export const PageLayout = ({ children }) => (

Maintenance Tasks Planner

      {children}

)
PageLayout.propTypes = {
  children: PropTypes.node,
}

export default PageLayout


text:
package acm

//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
)

// DescribeNamespaces invokes the acm.DescribeNamespaces API synchronously
// api document: https://help.aliyun.com/api/acm/describenamespaces.html
func (client *Client) DescribeNamespaces(request *DescribeNamespacesRequest) (response *DescribeNamespacesResponse, err error) {
	response = CreateDescribeNamespacesResponse()
	err = client.DoAction(request, response)
	return
}

// DescribeNamespacesWithChan invokes the acm.DescribeNamespaces API asynchronously
// api document: https://help.aliyun.com/api/acm/describenamespaces.html
// asynchronous document: https://help.aliyun.com/document_detail/66220.html
func (client *Client) DescribeNamespacesWithChan(request *DescribeNamespacesRequest) (<-chan *DescribeNamespacesResponse, <-chan error) {
	responseChan := make(chan *DescribeNamespacesResponse, 1)
	errChan := make(chan error, 1)
	err := client.AddAsyncTask(func() {
		defer close(responseChan)
		defer close(errChan)
		response, err := client.DescribeNamespaces(request)
		if err != nil {
			errChan <- err
		} else {
			responseChan <- response
		}
	})
	if err != nil {
		errChan <- err
		close(responseChan)
		close(errChan)
	}
	return responseChan, errChan
}

// DescribeNamespacesWithCallback invokes the acm.DescribeNamespaces API asynchronously
// api document: https://help.aliyun.com/api/acm/describenamespaces.html
// asynchronous document: https://help.aliyun.com/document_detail/66220.html
func (client *Client) DescribeNamespacesWithCallback(request *DescribeNamespacesRequest, callback func(response *DescribeNamespacesResponse, err error)) <-chan int {
	result := make(chan int, 1)
	err := client.AddAsyncTask(func() {
		var response *DescribeNamespacesResponse
		var err error
		defer close(result)
		response, err = client.DescribeNamespaces(request)
		callback(response, err)
		result <- 1
	})
	if err != nil {
		defer close(result)
		callback(nil, err)
		result <- 0
	}
	return result
}

// DescribeNamespacesRequest is the request struct for api DescribeNamespaces
type DescribeNamespacesRequest struct {
	*requests.RoaRequest
}

// DescribeNamespacesResponse is the response struct for api DescribeNamespaces
type DescribeNamespacesResponse struct {
	*responses.BaseResponse
	RequestId  string      `json:"RequestId" xml:"RequestId"`
	Code       string      `json:"Code" xml:"Code"`
	Message    string      `json:"Message" xml:"Message"`
	Namespaces []Namespace `json:"Namespaces" xml:"Namespaces"`
}

// CreateDescribeNamespacesRequest creates a request to invoke DescribeNamespaces API
func CreateDescribeNamespacesRequest() (request *DescribeNamespacesRequest) {
	request = &DescribeNamespacesRequest{
		RoaRequest: &requests.RoaRequest{},
	}
	request.InitWithApiInfo("acm", "2020-02-06", "DescribeNamespaces", "/diamond-ops/pop/namespace/list", "acms", "openAPI")
	request.Method = requests.GET
	return
}

// CreateDescribeNamespacesResponse creates a response to parse from DescribeNamespaces response
func CreateDescribeNamespacesResponse() (response *DescribeNamespacesResponse) {
	response = &DescribeNamespacesResponse{
		BaseResponse: &responses.BaseResponse{},
	}
	return
}


text:
package com.puppycrawl.tools.checkstyle.naming;

import java.io.Serializable;

public class InputTypeParameterName <t>
{
    public <TT> void foo() { }

    <e_e> void foo(int i) {
    }
}

class Other <foo extends Serializable & Cloneable> {

    foo getOne() {
	return null;//comment
    }

    <Tfo$o2T extends foo> /*comment*/Tfo$o2T getTwo(Tfo$o2T a) {
	return null;
    }

    <foo extends Runnable> foo getShadow() {
	return null;
    }

    static class Junk <foo> {
        <_fo extends foo> void getMoreFoo() {
	}
    }
}

class MoreOther <T extends Cloneable> {

    <E extends T> void getMore() {
        new Other() {
            <T> void getMoreFoo() {
	    }
	};

//        Other o = new Other() {
//            <EE> void getMoreFoo() {
//            }
//        };
    }
}

interface Boo<Input> {
    Input boo();
}

interface FooInterface<T> {
    T foo();
}

interface FooInterface2 {
    Input foo();
}

class Input {

}