text:
#import "_UISettings.h"

@interface PTXParallaxEngineSettings : _UISettings
{
    _Bool _shiftEnabled;
    _Bool _showIdleIndicator;
    _Bool _jumpEnabled;
    _Bool _playJumpSound;
    _Bool _directionalLockEnabled;
    _Bool _showDirectionalLockIndicators;
    unsigned long long _frameInterval;
    double _inputSmoothing;
    double _sigmoidDegree;
    double _shiftSpeed;
    double _shiftDistanceDependence;
    double _idleLeeway;
    double _delayBeforeIdle;
    double _jumpThreshold;
    double _directionalLockThreshold;
    double _directionalLockStickiness;
    double _directionalLockSharpness;
}

+ (id)settingsControllerModule;
@property _Bool showDirectionalLockIndicators; // @synthesize showDirectionalLockIndicators=_showDirectionalLockIndicators;
@property double directionalLockSharpness; // @synthesize directionalLockSharpness=_directionalLockSharpness;
@property double directionalLockStickiness; // @synthesize directionalLockStickiness=_directionalLockStickiness;
@property double directionalLockThreshold; // @synthesize directionalLockThreshold=_directionalLockThreshold;
@property _Bool directionalLockEnabled; // @synthesize directionalLockEnabled=_directionalLockEnabled;
@property _Bool playJumpSound; // @synthesize playJumpSound=_playJumpSound;
@property double jumpThreshold; // @synthesize jumpThreshold=_jumpThreshold;
@property _Bool jumpEnabled; // @synthesize jumpEnabled=_jumpEnabled;
@property _Bool showIdleIndicator; // @synthesize showIdleIndicator=_showIdleIndicator;
@property double delayBeforeIdle; // @synthesize delayBeforeIdle=_delayBeforeIdle;
@property double idleLeeway; // @synthesize idleLeeway=_idleLeeway;
@property double shiftDistanceDependence; // @synthesize shiftDistanceDependence=_shiftDistanceDependence;
@property double shiftSpeed; // @synthesize shiftSpeed=_shiftSpeed;
@property _Bool shiftEnabled; // @synthesize shiftEnabled=_shiftEnabled;
@property double sigmoidDegree; // @synthesize sigmoidDegree=_sigmoidDegree;
@property double inputSmoothing; // @synthesize inputSmoothing=_inputSmoothing;
@property unsigned long long frameInterval; // @synthesize frameInterval=_frameInterval;
- (void)setDefaultValues;

@end


text:
Originally published: 2014-04-10 01:14:34
Last updated: 2014-04-10 10:25:38
Author: Wykleph

If you have a listbox and need to filter the contents of the listbox based on the contents of an entry field, this will help you!  Shoutout to  Nikola-K for the revision.  It's much simpler now :D

redpajama_set_name: RedPajamaGithub


text:
static CFFGLPluginInfo PluginInfo(
	VizExample3::CreateInstance,	// Create method
	"VZDR",		// Plugin unique ID
	"VizExample3",	// Plugin name
	1,			// API major version number
	000,		// API minor version number
	1,			// Plugin major version number
	000,		// Plugin minor version number
	FF_EFFECT,	// Plugin type
	"VizExample3: draw sprites with TUIO input",	// description
	"by Tim Thompson - me@timthompson.com" 			// About
	);

std::string vizlet_name() { return "VizExample3"; }
CFFGLPluginInfo& vizlet_plugininfo() { return PluginInfo; }

VizExample3::VizExample3() : Vizlet() {
	m_params = new SpriteVizParams();
}

VizExample3::~VizExample3() {
}

DWORD __stdcall VizExample3::CreateInstance(CFreeFrameGLPlugin **ppInstance) {
	*ppInstance = new VizExample3();
	return (*ppInstance != NULL) ? FF_SUCCESS : FF_FAIL;
}

void VizExample3::processCursor(VizCursor* c, int downdragup) {
	// NO OpenGL calls here
	makeAndAddVizSprite(m_params, c->pos);
}

std::string VizExample3::processJson(std::string meth, cJSON *json, const char *id) {
	// NO OpenGL calls here
	if (meth == "apis") {
		return jsonStringResult("set_spriteparams(paramfile)", id);
	}

	// PARAMETER "spriteparams"
	if (meth == "set_spriteparams") {
		std::string file = jsonNeedString(json, "paramfile", "");
		if (file == "") {
			return jsonError(-32000, "Bad file value", id);
		}
		SpriteVizParams* p = readSpriteVizParams(file);
		if (p) {
			m_spriteparams = file;
			m_params = p;
		}
		return jsonOK(id);
	}
	if (meth == "get_spriteparams") {
		return jsonStringResult(m_spriteparams, id);
	}

	throw VizException("VizExample3 - Unrecognized method '%s'", meth.c_str());
}

bool VizExample3::processDraw() {
	// OpenGL calls here
	DrawVizSprites();
	return true;
}


text:
<component name="ArtifactManager">
  <artifact type="exploded-war" name="MyTamer:war exploded">
    <output-path>$PROJECT_DIR$/target/MyTamer-1.0-SNAPSHOT</output-path>
    <root id="root">
      <element id="directory" name="WEB-INF">
        <element id="directory" name="classes">
          <element id="module-output" name="MyTamer" />
        </element>
        <element id="directory" name="lib">
          <element id="library" level="project" name="Maven: com.google.appengine:appengine-api-1.0-sdk:1.9.18" />
          <element id="library" level="project" name="Maven: com.google.appengine:appengine-endpoints:1.9.18" />
          <element id="library" level="project" name="Maven: javax.inject:javax.inject:1" />
          <element id="library" level="project" name="Maven: javax.jdo:jdo-api:3.0.1" />
          <element id="library" level="project" name="Maven: javax.transaction:jta:1.1" />
        </element>
      </element>
      <element id="javaee-facet-resources" facet="MyTamer/web/Web" />
    </root>
  </artifact>
</component>


text:
<?xml version="1.0" encoding="utf-8" ?>
<Deployment xmlns="http://schemas.microsoft.com/windowsphone/2009/deployment" AppPlatformVersion="7.0">
  <App xmlns="" ProductID="{8dc22003-b1db-4670-a06f-7dd128cad744}" Title="SimpleAnimation" RuntimeType="XNA" Version="1.0.0.0" Genre="Apps.Normal" Author="" Description="" Publisher="">
    <IconPath IsRelative="true" IsResource="false"></IconPath>
    <Capabilities>
      <Capability Name="ID_CAP_NETWORKING" />
      <Capability Name="ID_CAP_LOCATION" />
      <Capability Name="ID_CAP_SENSORS" />
      <Capability Name="ID_CAP_MICROPHONE" />
      <Capability Name="ID_CAP_MEDIALIB" />
      <Capability Name="ID_CAP_GAMERSERVICES" />
      <Capability Name="ID_CAP_PHONEDIALER" />
      <Capability Name="ID_CAP_PUSH_NOTIFICATION" />
      <Capability Name="ID_CAP_WEBBROWSERCOMPONENT" />
      <Capability Name="ID_CAP_IDENTITY_USER" />
      <Capability Name="ID_CAP_IDENTITY_DEVICE" />
    </Capabilities>
    <Tasks>
      <DefaultTask Name="_default"/>
    </Tasks>
    <Tokens>
      <PrimaryToken TokenID="SimpleAnimationToken" TaskName="_default">
        <TemplateType5>
          <BackgroundImageURI IsRelative="true" IsResource="false"></BackgroundImageURI>
          <Count>0</Count>
          <Title></Title>
        </TemplateType5>
      </PrimaryToken>
    </Tokens>
  </App>
</Deployment>


text:
package com.kris.controller;

import com.kris.pojo.TaotaoResult;
import com.kris.pojo.TbContent;
import com.kris.service.ContentService;
import com.kris.utils.HttpClientUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author kris
 * @create 2016-12-27 17:17
 */
@Controller
@RequestMapping("/content")
public class ContentController {

    @Value("${REST_BASE_URL}")
    private String REST_BASE_URL;

    @Value("${REST_CONTENT_SYNC_URL}")
    private String REST_CONTENT_SYNC_URL;

    @Autowired
    private ContentService mContentService;

    @RequestMapping("/save")
    @ResponseBody
    public TaotaoResult insertContent(TbContent content) {
        TaotaoResult result = mContentService.insertContent(content);
        //调用taotao-rest发布的服务,同步缓存
        HttpClientUtil.doGet(REST_BASE_URL + REST_CONTENT_SYNC_URL + content.getCategoryId());
        return result;
    }
}


text:
Rails wrapper for RubyEventStore with batteries included.

Ships with asynchronous after-commit event dispatch on top of ActiveJob, ActiveSupport::Notifications instrumentation enabled, request metadata enrichment and opinionated directory structure generator for bounded contexts.

Find out more at [https://railseventstore.org](https://railseventstore.org/)


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

    <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
    <title>Statistics of PUNCT in UD_Korean-PUD</title>
    <link rel="root" href=""/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css">
    <link rel="stylesheet" type="text/css" href="../../css/jquery-ui-redmond.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/style-vis.css"/>
    <link rel="stylesheet" type="text/css" href="../../css/hint.css"/>

          home

          edit page
          issue tracker

          <gcse:search></gcse:search>

        This page pertains to UD version 2.

            It appears that you have Javascript disabled.
            Please consider enabling Javascript for this page to see the visualizations.

Treebank Statistics: UD_Korean-PUD: POS Tags: PUNCT

There are 14 PUNCT lemmas (1%), 14 PUNCT types (0%) and 1595 PUNCT tokens (10%).
Out of 13 observed tags, the rank of PUNCT is: 7 in number of lemmas, 12 in number of types and 3 in number of tokens.

The 10 most frequent PUNCT lemmas: ., ,, ", (, ), ", ", ', -, ?

The 10 most frequent PUNCT types:  ., ,, ", (, ), ", ", ', -, ?

The 10 most frequent ambiguous lemmas: _ (<tt>NOUN</tt> 4295, <tt>VERB</tt> 1439, <tt>PROPN</tt> 1030, <tt>AUX</tt> 663, <tt>ADJ</tt> 596, <tt>ADV</tt> 516, <tt>DET</tt> 462, <tt>CCONJ</tt> 125, <tt>X</tt> 47, <tt>NUM</tt> 27, <tt>PRON</tt> 24, <tt>PUNCT</tt> 1)

The 10 most frequent ambiguous types:

Morphology

The form / lemma ratio of PUNCT is 1.000000 (the average of all parts of speech is 3.187571).

The 1st highest number of forms (1) was observed with the lemma """: ".

The 2nd highest number of forms (1) was observed with the lemma "'": '.

The 3rd highest number of forms (1) was observed with the lemma "(": (.

PUNCT does not occur with any features.

Relations

PUNCT nodes are attached to their parents using 1 different relations: <tt>punct</tt> (1595; 100% instances)

Parents of PUNCT nodes belong to 11 different parts of speech: <tt>NOUN</tt> (840; 53% instances), <tt>VERB</tt> (335; 21% instances), <tt>PROPN</tt> (155; 10% instances), <tt>ADJ</tt> (137; 9% instances), <tt>AUX</tt> (57; 4% instances), <tt>ADV</tt> (26; 2% instances), <tt>NUM</tt> (20; 1% instances), <tt>PART</tt> (14; 1% instances), <tt>DET</tt> (5; 0% instances), <tt>PRON</tt> (5; 0% instances), <tt>X</tt> (1; 0% instances)

1595 (100%) PUNCT nodes are leaves.

The highest child degree of a PUNCT node is 0.

© 2014–2021
            Universal Dependencies contributors.
            Site powered by Annodoc and brat
.


text:
{% load i18n %}<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

    <title>{% block title %}Yet another feedzilla site{% endblock %}</title>
    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    <meta name="keywords" content="{% block meta_keywords %}{% endblock %}" />
    <meta name="description" content="{% block meta_description %}{% endblock %}" />
    <link rel="alternate" type="application/atom+xml" href="{% url "feedzilla_feed" "posts" %}" title="Yet another feedzilla site" />

    <link type="text/css" rel="stylesheet" href="{{ MEDIA_URL }}feedzilla/css/reset.css" />
    <link type="text/css" rel="stylesheet" href="{{ MEDIA_URL }}feedzilla/css/style.css" />

    {% block extra_js %}{% endblock %}

Yet another feedzilla site

Description of this cool site

                    <form class="search-form" action="{% url "feedzilla_search" %}" method="get">
                        <input id="id_query" type="text" maxlength="64" name="query" value="{% block feedzilla_query_value %}{% endblock %}" />
                        <input type="submit" class="submit" value="{% trans "Search" %}" />
                    </form>

{% trans "News stream" %}

{% trans "Sources" %}

                    {% block content %}{% endblock %}

                    {% include "feedzilla/_sidebar.html" %}
                    {% include "feedzilla/_sidebar_extra.html" %}

                {% include "footer.html" %}


text:
package com.instancedev.skins.mobs;

import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;

public class Enderman {
	public static void buildEnderman(Location start, String direction){
		buildLegs(start, direction);
		buildArms(start, direction);
		buildBody(start, direction);
		buildHead(start, direction);
	}

	public static void buildLegs(Location start, String d){
		for(int i__ = 0; i__ < 2; i__++){
			for(int i_ = 0; i_ < 2; i_++){
				for(int i = 0; i < 24; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i, start.getBlockZ() - i_));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__ + 1, start.getBlockY() + i, start.getBlockZ() + i_));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_, start.getBlockY() + i, start.getBlockZ() - i__ - 1));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_, start.getBlockY() + i, start.getBlockZ() + i__ + 1));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i, start.getBlockZ() - i_));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}

		for(int i__ = 0; i__ < 2; i__++){
			for(int i_ = 0; i_ < 2; i_++){
				for(int i = 0; i < 24; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i, start.getBlockZ() - i_ - 4));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__ + 1, start.getBlockY() + i, start.getBlockZ() + i_ + 4));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_ + 4, start.getBlockY() + i, start.getBlockZ() - i__ - 1));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_ - 4, start.getBlockY() + i, start.getBlockZ() + i__ + 1));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i, start.getBlockZ() - i_ - 4));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}
	}

	public static void buildArms(Location start, String d){
		for(int i__ = 0; i__ < 2; i__++){
			for(int i_ = 0; i_ < 2; i_++){
				for(int i = 0; i < 24; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i + 12, start.getBlockZ() - i_ + 3));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__ + 1, start.getBlockY() + i + 12, start.getBlockZ() + i_ - 3));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_ - 3, start.getBlockY() + i + 12, start.getBlockZ() - i__ - 1));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_ + 3, start.getBlockY() + i + 12, start.getBlockZ() + i__ + 1));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i + 12, start.getBlockZ() - i_));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}

		for(int i__ = 0; i__ < 2; i__++){
			for(int i_ = 0; i_ < 2; i_++){
				for(int i = 0; i < 24; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i + 12, start.getBlockZ() - i_ - 7));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__ + 1, start.getBlockY() + i + 12, start.getBlockZ() + i_ + 7));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_ + 7, start.getBlockY() + i + 12, start.getBlockZ() - i__ - 1));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_ - 7, start.getBlockY() + i + 12, start.getBlockZ() + i__ + 1));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ - 1, start.getBlockY() + i + 12, start.getBlockZ() - i_ - 7));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}
	}

	public static void buildBody(Location start, String d){
		for(int i__ = 0; i__ < 4; i__++){
			for(int i_ = 0; i_ < 8; i_++){
				for(int i = 0; i < 12; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__, start.getBlockY() + i + 24, start.getBlockZ() - i_ + 1));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__, start.getBlockY() + i + 24, start.getBlockZ() + i_ - 1));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_ - 1, start.getBlockY() + i + 24, start.getBlockZ() - i__));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_ + 1, start.getBlockY() + i + 24, start.getBlockZ() + i__));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__, start.getBlockY() + i + 24, start.getBlockZ() - i_ + 1));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}
	}

	public static void buildHead(Location start, String d){
		for(int i__ = 0; i__ < 8; i__++){
			for(int i_ = 0; i_ < 8; i_++){
				for(int i = 0; i < 8; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ + 2, start.getBlockY() + i + 36, start.getBlockZ() - i_ + 1));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i__ - 2, start.getBlockY() + i + 36, start.getBlockZ() + i_ - 1));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + i_ - 1, start.getBlockY() + i + 36, start.getBlockZ() - i__ + 2));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i_ + 1, start.getBlockY() + i + 36, start.getBlockZ() + i__ - 2));
					}else{
						b = start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - i__ + 2, start.getBlockY() + i + 36, start.getBlockZ() - i_ + 1));
					}
					b.setType(Material.WOOL);
					b.setData((byte)15);
				}
			}
		}

		// eyes
		if(d.equalsIgnoreCase("west")){
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() + 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ())).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 4)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 5)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 6)).setTypeIdAndData(35, (byte)0, true);
		}else if(d.equalsIgnoreCase("east")){
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ() - 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ())).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ() + 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ() + 4)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ() + 5)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 2, start.getBlockY() + 39, start.getBlockZ() + 6)).setTypeIdAndData(35, (byte)0, true);
		}else if(d.equalsIgnoreCase("north")){
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 1, start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX(), start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 1, start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 4, start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 5, start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 6, start.getBlockY() + 39, start.getBlockZ() + 2)).setTypeIdAndData(35, (byte)0, true);
		}else if(d.equalsIgnoreCase("south")){
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 1, start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX(), start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 1, start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 4, start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 5, start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() - 6, start.getBlockY() + 39, start.getBlockZ() - 2)).setTypeIdAndData(35, (byte)0, true);
		}else{
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() + 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ())).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 1)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 4)).setTypeIdAndData(35, (byte)0, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 5)).setTypeIdAndData(35, (byte)10, true);
			start.getWorld().getBlockAt(new Location(start.getWorld(), start.getBlockX() + 2, start.getBlockY() + 39, start.getBlockZ() - 6)).setTypeIdAndData(35, (byte)0, true);
		}
	}

	public static void undoEnderman(Location start, String d){
		World w = start.getWorld();
		for(int i__ = 0; i__ < 8; i__++){
			for(int i_ = 0; i_ < 16; i_++){
				for(int i = 0; i < 44; i++){
					Block b;
					if(d.equalsIgnoreCase("west")){
						b = start.getWorld().getBlockAt(new Location(w, start.getBlockX() - i__ + 2, start.getBlockY() + i, start.getBlockZ() - i_ + 3));
					}else if(d.equalsIgnoreCase("east")){
						b = start.getWorld().getBlockAt(new Location(w, start.getBlockX() + i__ - 2, start.getBlockY() + i, start.getBlockZ() + i_ - 3));
					}else if(d.equalsIgnoreCase("north")){
						b = start.getWorld().getBlockAt(new Location(w, start.getBlockX() + i_ - 3, start.getBlockY() + i, start.getBlockZ() - i__ + 2));
					}else if(d.equalsIgnoreCase("south")){
						b = start.getWorld().getBlockAt(new Location(w, start.getBlockX() - i_ + 3, start.getBlockY() + i, start.getBlockZ() + i__ - 2));
					}else{
						b = start.getWorld().getBlockAt(new Location(w, start.getBlockX() - i__ + 2, start.getBlockY() + i, start.getBlockZ() - i_ + 3));
					}
					if(b.getType() == Material.WOOL){
						b.setType(Material.AIR);
					}
				}
			}
		}
	}
}


text:
ScalaJS.impls.scala_collection_convert_Wrappers$class__$init$__Lscala_collection_convert_Wrappers__V = (function($$this) {
  /*<skip>*/
});
//@ sourceMappingURL=Wrappers$class.js.map


text:
use compiler::TemplateCompiler;
use error::Error::*;
use error::*;
use instruction::{Instruction, PathSlice, PathStep};
use serde_json::Value;
use std::collections::HashMap;
use std::fmt::Write;
use std::slice;
use ValueFormatter;

/// Enum defining the different kinds of records on the context stack.
enum ContextElement<'render, 'template> {
    /// Object contexts shadow everything below them on the stack, because every name is looked up
    /// in this object.
    Object(&'render Value),
    /// Named contexts shadow only one name. Any path that starts with that name is looked up in
    /// this object, and all others are passed on down the stack.
    Named(&'template str, &'render Value),
    /// Iteration contexts shadow one name with the current value of the iteration. They also
    /// store the iteration state. The two usizes are the index of the current value and the length
    /// of the array that we're iterating over.
    Iteration(
        &'template str,
        &'render Value,
        usize,
        usize,
        slice::Iter<'render, Value>,
    ),
}

/// Helper struct which mostly exists so that I have somewhere to put functions that access the
/// rendering context stack.
struct RenderContext<'render, 'template> {
    original_text: &'template str,
    context_stack: Vec<ContextElement<'render, 'template>>,
}
impl<'render, 'template> RenderContext<'render, 'template> {
    /// Look up the given path in the context stack and return the value (if found) or an error (if
    /// not)
    fn lookup(&self, path: PathSlice) -> Result<&'render Value> {
        for stack_layer in self.context_stack.iter().rev() {
            match stack_layer {
                ContextElement::Object(obj) => return self.lookup_in(path, obj),
                ContextElement::Named(name, obj) => {
                    if *name == &*path[0] {
                        return self.lookup_in(&path[1..], obj);
                    }
                }
                ContextElement::Iteration(name, obj, _, _, _) => {
                    if *name == &*path[0] {
                        return self.lookup_in(&path[1..], obj);
                    }
                }
            }
        }
        panic!("Attempted to do a lookup with an empty context stack. That shouldn't be possible.")
    }

    /// Look up a path within a given value object and return the resulting value (if found) or
    /// an error (if not)
    fn lookup_in(&self, path: PathSlice, object: &'render Value) -> Result<&'render Value> {
        let mut current = object;
        for step in path.iter() {
            if let PathStep::Index(_, n) = step {
                if let Some(next) = current.get(n) {
                    current = next;
                    continue;
                }
            }

            let step: &str = &*step;

            match current.get(step) {
                Some(next) => current = next,
                None => return Err(lookup_error(self.original_text, step, path, current)),
            }
        }
        Ok(current)
    }

    /// Look up the index and length values for the top iteration context on the stack.
    fn lookup_index(&self) -> Result<(usize, usize)> {
        for stack_layer in self.context_stack.iter().rev() {
            match stack_layer {
                ContextElement::Iteration(_, _, index, length, _) => return Ok((*index, *length)),
                _ => continue,
            }
        }
        Err(GenericError {
            msg: "Used @index outside of a foreach block.".to_string(),
        })
    }

    /// Look up the root context object
    fn lookup_root(&self) -> Result<&'render Value> {
        match self.context_stack.get(0) {
            Some(ContextElement::Object(obj)) => Ok(obj),
            Some(_) => {
                panic!("Expected Object value at root of context stack, but was something else.")
            }
            None => panic!(
                "Attempted to do a lookup with an empty context stack. That shouldn't be possible."
            ),
        }
    }
}

/// Structure representing a parsed template. It holds the bytecode program for rendering the
/// template as well as the length of the original template string, which is used as a guess to
/// pre-size the output string buffer.
pub(crate) struct Template<'template> {
    original_text: &'template str,
    instructions: Vec<Instruction<'template>>,
    template_len: usize,
}
impl<'template> Template<'template> {
    /// Create a Template from the given template string.
    pub fn compile(text: &'template str) -> Result<Template> {
        Ok(Template {
            original_text: text,
            template_len: text.len(),
            instructions: TemplateCompiler::new(text).compile()?,
        })
    }

    /// Render this template into a string and return it (or any error if one is encountered).
    pub fn render(
        &self,
        context: &Value,
        template_registry: &HashMap<&str, Template>,
        formatter_registry: &HashMap<&str, Box<ValueFormatter>>,
        default_formatter: &ValueFormatter,
    ) -> Result<String> {
        // The length of the original template seems like a reasonable guess at the length of the
        // output.
        let mut output = String::with_capacity(self.template_len);
        self.render_into(
            context,
            template_registry,
            formatter_registry,
            default_formatter,
            &mut output,
        )?;
        Ok(output)
    }

    /// Render this template into a given string. Used for calling other templates.
    pub fn render_into(
        &self,
        context: &Value,
        template_registry: &HashMap<&str, Template>,
        formatter_registry: &HashMap<&str, Box<ValueFormatter>>,
        default_formatter: &ValueFormatter,
        output: &mut String,
    ) -> Result<()> {
        let mut program_counter = 0;
        let mut render_context = RenderContext {
            original_text: self.original_text,
            context_stack: vec![ContextElement::Object(context)],
        };

        while program_counter < self.instructions.len() {
            match &self.instructions[program_counter] {
                Instruction::Literal(text) => {
                    output.push_str(text);
                    program_counter += 1;
                }
                Instruction::Value(path) => {
                    let first = path.first().unwrap();
                    if first.starts_with('@') {
                        // Currently we just hard-code the special @-keywords and have special
                        // lookup functions to use them because there are lifetime complexities with
                        // looking up values that don't live for as long as the given context object.
                        let first: &str = &*first;
                        match first {
                            "@index" => {
                                write!(output, "{}", render_context.lookup_index()?.0).unwrap()
                            }
                            "@first" => {
                                write!(output, "{}", render_context.lookup_index()?.0 == 0).unwrap()
                            }
                            "@last" => {
                                let (index, length) = render_context.lookup_index()?;
                                write!(output, "{}", index == length - 1).unwrap()
                            }
                            "@root" => {
                                let value_to_render = render_context.lookup_root()?;
                                default_formatter(value_to_render, output)?;
                            }
                            _ => panic!(), // This should have been caught by the parser.
                        }
                    } else {
                        let value_to_render = render_context.lookup(path)?;
                        default_formatter(value_to_render, output)?;
                    }
                    program_counter += 1;
                }
                Instruction::FormattedValue(path, name) => {
                    // The @ keywords aren't supported for formatted values. Should they be?
                    let value_to_render = render_context.lookup(path)?;
                    match formatter_registry.get(name) {
                        Some(formatter) => {
                            let formatter_result = formatter(value_to_render, output);
                            if let Err(err) = formatter_result {
                                return Err(called_formatter_error(self.original_text, name, err));
                            }
                        }
                        None => return Err(unknown_formatter(self.original_text, name)),
                    }
                    program_counter += 1;
                }
                Instruction::Branch(path, negate, target) => {
                    let first = path.first().unwrap();
                    let mut truthy = if first.starts_with('@') {
                        let first: &str = &*first;
                        match &*first {
                            "@index" => render_context.lookup_index()?.0 != 0,
                            "@first" => render_context.lookup_index()?.0 == 0,
                            "@last" => {
                                let (index, length) = render_context.lookup_index()?;
                                index == (length - 1)
                            }
                            "@root" => self.value_is_truthy(render_context.lookup_root()?, path)?,
                            other => panic!("Unknown keyword {}", other), // This should have been caught by the parser.
                        }
                    } else {
                        let value_to_render = render_context.lookup(path)?;
                        self.value_is_truthy(value_to_render, path)?
                    };
                    if *negate {
                        truthy = !truthy;
                    }

                    if truthy {
                        program_counter = *target;
                    } else {
                        program_counter += 1;
                    }
                }
                Instruction::PushNamedContext(path, name) => {
                    let context_value = render_context.lookup(path)?;
                    render_context
                        .context_stack
                        .push(ContextElement::Named(name, context_value));
                    program_counter += 1;
                }
                Instruction::PushIterationContext(path, name) => {
                    // We push a context with an invalid index and no value and then wait for the
                    // following Iterate instruction to set the index and value properly.
                    let first = path.first().unwrap();
                    let context_value = match first {
                        PathStep::Name("@root") => render_context.lookup_root()?,
                        PathStep::Name(other) if other.starts_with('@') => {
                            return Err(not_iterable_error(self.original_text, path))
                        }
                        _ => render_context.lookup(path)?,
                    };
                    match context_value {
                        Value::Array(ref arr) => {
                            render_context.context_stack.push(ContextElement::Iteration(
                                name,
                                &Value::Null,
                                ::std::usize::MAX,
                                arr.len(),
                                arr.iter(),
                            ))
                        }
                        _ => return Err(not_iterable_error(self.original_text, path)),
                    };
                    program_counter += 1;
                }
                Instruction::PopContext => {
                    render_context.context_stack.pop();
                    program_counter += 1;
                }
                Instruction::Goto(target) => {
                    program_counter = *target;
                }
                Instruction::Iterate(target) => {
                    match render_context.context_stack.last_mut() {
                        Some(ContextElement::Iteration(_, val, index, _, iter)) => {
                            match iter.next() {
                                Some(new_val) => {
                                    *val = new_val;
                                    // On the first iteration, this will be usize::MAX so it will
                                    // wrap around to zero.
                                    *index = index.wrapping_add(1);
                                    program_counter += 1;
                                }
                                None => {
                                    program_counter = *target;
                                }
                            }
                        }
                        _ => panic!("Malformed program."),
                    };
                }
                Instruction::Call(template_name, path) => {
                    let context_value = render_context.lookup(path)?;
                    match template_registry.get(template_name) {
                        Some(templ) => {
                            let called_templ_result = templ.render_into(
                                context_value,
                                template_registry,
                                formatter_registry,
                                default_formatter,
                                output,
                            );
                            if let Err(err) = called_templ_result {
                                return Err(called_template_error(
                                    self.original_text,
                                    template_name,
                                    err,
                                ));
                            }
                        }
                        None => return Err(unknown_template(self.original_text, template_name)),
                    }
                    program_counter += 1;
                }
            }
        }
        Ok(())
    }

    fn value_is_truthy(&self, value: &Value, path: PathSlice) -> Result<bool> {
        let truthy = match value {
            Value::Null => false,
            Value::Bool(b) => *b,
            Value::Number(n) => match n.as_f64() {
                Some(float) => float != 0.0,
                None => {
                    return Err(truthiness_error(self.original_text, path));
                }
            },
            Value::String(s) => !s.is_empty(),
            Value::Array(arr) => !arr.is_empty(),
            Value::Object(_) => true,
        };
        Ok(truthy)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use compiler::TemplateCompiler;

    fn compile(text: &'static str) -> Template<'static> {
        Template {
            original_text: text,
            template_len: text.len(),
            instructions: TemplateCompiler::new(text).compile().unwrap(),
        }
    }

    #[derive(Serialize)]
    struct NestedContext {
        value: usize,
    }

    #[derive(Serialize)]
    struct TestContext {
        number: usize,
        string: &'static str,
        boolean: bool,
        null: Option<usize>,
        array: Vec<usize>,
        nested: NestedContext,
        escapes: &'static str,
    }

    fn context() -> Value {
        let ctx = TestContext {
            number: 5,
            string: "test",
            boolean: true,
            null: None,
            array: vec![1, 2, 3],
            nested: NestedContext { value: 10 },
            escapes: "1:< 2:> 3:& 4:' 5:\"",
        };
        ::serde_json::to_value(&ctx).unwrap()
    }

    fn other_templates() -> HashMap<&'static str, Template<'static>> {
        let mut map = HashMap::new();
        map.insert("my_macro", compile("{value}"));
        map
    }

    fn format(value: &Value, output: &mut String) -> Result<()> {
        output.push_str("{");
        ::format(value, output)?;
        output.push_str("}");
        Ok(())
    }

    fn formatters() -> HashMap<&'static str, Box<ValueFormatter>> {
        let mut map = HashMap::<&'static str, Box<ValueFormatter>>::new();
        map.insert("my_formatter", Box::new(format));
        map
    }

    pub fn default_formatter() -> &'static ValueFormatter {
        &::format
    }

    #[test]
    fn test_literal() {
        let template = compile("Hello!");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello!", &string);
    }

    #[test]
    fn test_value() {
        let template = compile("{ number }");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("5", &string);
    }

    #[test]
    fn test_path() {
        let template = compile("The number of the day is { nested.value }.");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("The number of the day is 10.", &string);
    }

    #[test]
    fn test_if_taken() {
        let template = compile("{{ if boolean }}Hello!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello!", &string);
    }

    #[test]
    fn test_if_untaken() {
        let template = compile("{{ if null }}Hello!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("", &string);
    }

    #[test]
    fn test_if_else_taken() {
        let template = compile("{{ if boolean }}Hello!{{ else }}Goodbye!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello!", &string);
    }

    #[test]
    fn test_if_else_untaken() {
        let template = compile("{{ if null }}Hello!{{ else }}Goodbye!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Goodbye!", &string);
    }

    #[test]
    fn test_ifnot_taken() {
        let template = compile("{{ if not boolean }}Hello!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("", &string);
    }

    #[test]
    fn test_ifnot_untaken() {
        let template = compile("{{ if not null }}Hello!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello!", &string);
    }

    #[test]
    fn test_ifnot_else_taken() {
        let template = compile("{{ if not boolean }}Hello!{{ else }}Goodbye!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Goodbye!", &string);
    }

    #[test]
    fn test_ifnot_else_untaken() {
        let template = compile("{{ if not null }}Hello!{{ else }}Goodbye!{{ endif }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello!", &string);
    }

    #[test]
    fn test_nested_ifs() {
        let template = compile(
            "{{ if boolean }}Hi, {{ if null }}there!{{ else }}Hello!{{ endif }}{{ endif }}",
        );
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hi, Hello!", &string);
    }

    #[test]
    fn test_with() {
        let template = compile("{{ with nested as n }}{ n.value } { number }{{endwith}}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("10 5", &string);
    }

    #[test]
    fn test_for_loop() {
        let template = compile("{{ for a in array }}{ a }{{ endfor }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("123", &string);
    }

    #[test]
    fn test_for_loop_index() {
        let template = compile("{{ for a in array }}{ @index }{{ endfor }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("012", &string);
    }

    #[test]
    fn test_for_loop_first() {
        let template =
            compile("{{ for a in array }}{{if @first }}{ @index }{{ endif }}{{ endfor }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("0", &string);
    }

    #[test]
    fn test_for_loop_last() {
        let template =
            compile("{{ for a in array }}{{ if @last}}{ @index }{{ endif }}{{ endfor }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("2", &string);
    }

    #[test]
    fn test_whitespace_stripping_value() {
        let template = compile("1  \n\t   {- number -}  \n   1");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("151", &string);
    }

    #[test]
    fn test_call() {
        let template = compile("{{ call my_macro with nested }}");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("10", &string);
    }

    #[test]
    fn test_formatter() {
        let template = compile("{ nested.value | my_formatter }");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("{10}", &string);
    }

    #[test]
    fn test_unknown() {
        let template = compile("{ foobar }");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap_err();
    }

    #[test]
    fn test_escaping() {
        let template = compile("{ escapes }");
        let context = context();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("1:< 2:> 3:& 4:' 5:"", &string);
    }

    #[test]
    fn test_unescaped() {
        let template = compile("{ escapes | unescaped }");
        let context = context();
        let template_registry = other_templates();
        let mut formatter_registry = formatters();
        formatter_registry.insert("unescaped", Box::new(::format_unescaped));
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("1:< 2:> 3:& 4:' 5:\"", &string);
    }

    #[test]
    fn test_root_print() {
        let template = compile("{ @root }");
        let context = "Hello World!";
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello World!", &string);
    }

    #[test]
    fn test_root_branch() {
        let template = compile("{{ if @root }}Hello World!{{ endif }}");
        let context = true;
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("Hello World!", &string);
    }

    #[test]
    fn test_root_iterate() {
        let template = compile("{{ for a in @root }}{ a }{{ endfor }}");
        let context = vec!["foo", "bar"];
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("foobar", &string);
    }

    #[test]
    fn test_number_truthiness_zero() {
        let template = compile("{{ if @root }}truthy{{else}}not truthy{{ endif }}");
        let context = 0;
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("not truthy", &string);
    }

    #[test]
    fn test_number_truthiness_one() {
        let template = compile("{{ if @root }}truthy{{else}}not truthy{{ endif }}");
        let context = 1;
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("truthy", &string);
    }

    #[test]
    fn test_indexed_paths() {
        #[derive(Serialize)]
        struct Context {
            foo: (usize, usize),
        }

        let template = compile("{ foo.1 }{ foo.0 }");
        let context = Context { foo: (123, 456) };
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("456123", &string);
    }

    #[test]
    fn test_indexed_paths_fall_back_to_string_lookup() {
        #[derive(Serialize)]
        struct Context {
            foo: HashMap<&'static str, usize>,
        }

        let template = compile("{ foo.1 }{ foo.0 }");
        let mut foo = HashMap::new();
        foo.insert("0", 123);
        foo.insert("1", 456);
        let context = Context { foo };
        let context = ::serde_json::to_value(&context).unwrap();
        let template_registry = other_templates();
        let formatter_registry = formatters();
        let string = template
            .render(
                &context,
                &template_registry,
                &formatter_registry,
                &default_formatter(),
            )
            .unwrap();
        assert_eq!("456123", &string);
    }
}


text:
package rocks.boltsandnuts.falsework.client.gui;

//Creates your creative tab.

import rocks.boltsandnuts.falsework.ModInformation;
import rocks.boltsandnuts.falsework.items.ItemRegistry;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

public class CreativeTabBaseMod extends CreativeTabs {

	public CreativeTabBaseMod(String tabLabel) {
		super(tabLabel);
		setBackgroundImageName(ModInformation.ID + ".png"); // Automagically has tab_ applied to it. Make sure you change the texture name.
	}

	public boolean hasSearchBar() {
		return true;
	}

	//The tab icon is what you return here.
	@Override
	public ItemStack getIconItemStack() {
		return new ItemStack(ItemRegistry.quisqueLapis);
	}

	@Override
	public Item getTabIconItem() {
		return new Item();
	}
}


text:
package com.com.sky.downloader.greendao;

import java.util.Map;

import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.AbstractDaoSession;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.identityscope.IdentityScopeType;
import org.greenrobot.greendao.internal.DaoConfig;

import com.tiny.demo.firstlinecode.storage.greendao.bean.User;

import com.com.sky.downloader.greendao.UserDao;

// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.

/**
 * {@inheritDoc}
 *
 * @see org.greenrobot.greendao.AbstractDaoSession
 */
public class DaoSession extends AbstractDaoSession {

    private final DaoConfig userDaoConfig;

    private final UserDao userDao;

    public DaoSession(Database db, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>
            daoConfigMap) {
        super(db);

        userDaoConfig = daoConfigMap.get(UserDao.class).clone();
        userDaoConfig.initIdentityScope(type);

        userDao = new UserDao(userDaoConfig, this);

        registerDao(User.class, userDao);
    }

    public void clear() {
        userDaoConfig.clearIdentityScope();
    }

    public UserDao getUserDao() {
        return userDao;
    }

}


text:
/* @(#) $Id$ */

#ifndef ZCONF_H
#define ZCONF_H

#ifdef __APPLE__
/* use wxWidgets' configure */
#include "wx/setup.h"
#endif

/* wxWidgets always uses custom prefix to avoid conflicts. */
#define Z_PREFIX_ wx_zlib_

/*
 * Defining custom Z_PREFIX_ implies using Z_PREFIX.
 */
#if defined(Z_PREFIX_) && !defined(Z_PREFIX)
#  define Z_PREFIX 1
#endif

/*
 * If you *really* need a unique prefix for all types and library functions,
 * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
 * Even better than compiling with -DZ_PREFIX would be to use configure to set
 * this permanently in zconf.h using "./configure --zprefix".
 */
#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
#  define Z_PREFIX_SET

#define ZLIB_CONCAT2(x, y) x ## y
#define ZLIB_CONCAT(x, y) ZLIB_CONCAT2(x, y)

/*
 * If a custom prefix is defined, use it. Otherwise use the default "z_".
 */
#ifdef Z_PREFIX_
#  define Z_ADD_PREFIX(name) ZLIB_CONCAT(Z_PREFIX_, name)
#else
#  define Z_ADD_PREFIX(name) ZLIB_CONCAT(z_, name)
#endif

/*
 * For macros the standard prefix is always used, as we can't define them
 * using names constructed using arbitrary Z_PREFIX_ value -- but luckily this
 * doesn't matter anyhow, because we can't have link-time conflicts for macros.
 */
#define Z_ADD_PREFIX_STD(name) ZLIB_CONCAT(z_, name)

/* all linked symbols and init macros */
#  define _dist_code            Z_ADD_PREFIX(_dist_code)
#  define _length_code          Z_ADD_PREFIX(_length_code)
#  define _tr_align             Z_ADD_PREFIX(_tr_align)
#  define _tr_flush_bits        Z_ADD_PREFIX(_tr_flush_bits)
#  define _tr_flush_block       Z_ADD_PREFIX(_tr_flush_block)
#  define _tr_init              Z_ADD_PREFIX(_tr_init)
#  define _tr_stored_block      Z_ADD_PREFIX(_tr_stored_block)
#  define _tr_tally             Z_ADD_PREFIX(_tr_tally)
#  define adler32               Z_ADD_PREFIX(adler32)
#  define adler32_combine       Z_ADD_PREFIX(adler32_combine)
#  define adler32_combine64     Z_ADD_PREFIX(adler32_combine64)
#  define adler32_z             Z_ADD_PREFIX(adler32_z)
#  ifndef Z_SOLO
#    define compress              Z_ADD_PREFIX(compress)
#    define compress2             Z_ADD_PREFIX(compress2)
#    define compressBound         Z_ADD_PREFIX(compressBound)
#  endif
#  define crc32                 Z_ADD_PREFIX(crc32)
#  define crc32_combine         Z_ADD_PREFIX(crc32_combine)
#  define crc32_combine64       Z_ADD_PREFIX(crc32_combine64)
#  define crc32_z               Z_ADD_PREFIX(crc32_z)
#  define deflate               Z_ADD_PREFIX(deflate)
#  define deflateBound          Z_ADD_PREFIX(deflateBound)
#  define deflateCopy           Z_ADD_PREFIX(deflateCopy)
#  define deflateEnd            Z_ADD_PREFIX(deflateEnd)
#  define deflateGetDictionary  Z_ADD_PREFIX(deflateGetDictionary)
#  define deflateInit           Z_ADD_PREFIX_STD(deflateInit)
#  define deflateInit2          Z_ADD_PREFIX_STD(deflateInit2)
#  define deflateInit2_         Z_ADD_PREFIX(deflateInit2_)
#  define deflateInit_          Z_ADD_PREFIX(deflateInit_)
#  define deflateParams         Z_ADD_PREFIX(deflateParams)
#  define deflatePending        Z_ADD_PREFIX(deflatePending)
#  define deflatePrime          Z_ADD_PREFIX(deflatePrime)
#  define deflateReset          Z_ADD_PREFIX(deflateReset)
#  define deflateResetKeep      Z_ADD_PREFIX(deflateResetKeep)
#  define deflateSetDictionary  Z_ADD_PREFIX(deflateSetDictionary)
#  define deflateSetHeader      Z_ADD_PREFIX(deflateSetHeader)
#  define deflateTune           Z_ADD_PREFIX(deflateTune)
#  define deflate_copyright     Z_ADD_PREFIX(deflate_copyright)
#  define get_crc_table         Z_ADD_PREFIX(get_crc_table)
#  ifndef Z_SOLO
#    define gz_error              Z_ADD_PREFIX(gz_error)
#    define gz_intmax             Z_ADD_PREFIX(gz_intmax)
#    define gz_strwinerror        Z_ADD_PREFIX(gz_strwinerror)
#    define gzbuffer              Z_ADD_PREFIX(gzbuffer)
#    define gzclearerr            Z_ADD_PREFIX(gzclearerr)
#    define gzclose               Z_ADD_PREFIX(gzclose)
#    define gzclose_r             Z_ADD_PREFIX(gzclose_r)
#    define gzclose_w             Z_ADD_PREFIX(gzclose_w)
#    define gzdirect              Z_ADD_PREFIX(gzdirect)
#    define gzdopen               Z_ADD_PREFIX(gzdopen)
#    define gzeof                 Z_ADD_PREFIX(gzeof)
#    define gzerror               Z_ADD_PREFIX(gzerror)
#    define gzflush               Z_ADD_PREFIX(gzflush)
#    define gzfread               Z_ADD_PREFIX(gzfread)
#    define gzfwrite              Z_ADD_PREFIX(gzfwrite)
#    define gzgetc                Z_ADD_PREFIX(gzgetc)
#    define gzgetc_               Z_ADD_PREFIX(gzgetc_)
#    define gzgets                Z_ADD_PREFIX(gzgets)
#    define gzoffset              Z_ADD_PREFIX(gzoffset)
#    define gzoffset64            Z_ADD_PREFIX(gzoffset64)
#    define gzopen                Z_ADD_PREFIX(gzopen)
#    define gzopen64              Z_ADD_PREFIX(gzopen64)
#    ifdef _WIN32
#      define gzopen_w              Z_ADD_PREFIX(gzopen_w)
#    endif
#    define gzprintf              Z_ADD_PREFIX(gzprintf)
#    define gzputc                Z_ADD_PREFIX(gzputc)
#    define gzputs                Z_ADD_PREFIX(gzputs)
#    define gzread                Z_ADD_PREFIX(gzread)
#    define gzrewind              Z_ADD_PREFIX(gzrewind)
#    define gzseek                Z_ADD_PREFIX(gzseek)
#    define gzseek64              Z_ADD_PREFIX(gzseek64)
#    define gzsetparams           Z_ADD_PREFIX(gzsetparams)
#    define gztell                Z_ADD_PREFIX(gztell)
#    define gztell64              Z_ADD_PREFIX(gztell64)
#    define gzungetc              Z_ADD_PREFIX(gzungetc)
#    define gzvprintf             Z_ADD_PREFIX(gzvprintf)
#    define gzwrite               Z_ADD_PREFIX(gzwrite)
#  endif
#  define inflate               Z_ADD_PREFIX(inflate)
#  define inflateBack           Z_ADD_PREFIX(inflateBack)
#  define inflateBackEnd        Z_ADD_PREFIX(inflateBackEnd)
#  define inflateBackInit       Z_ADD_PREFIX_STD(inflateBackInit)
#  define inflateBackInit_      Z_ADD_PREFIX(inflateBackInit_)
#  define inflateCodesUsed      Z_ADD_PREFIX(inflateCodesUsed)
#  define inflateCopy           Z_ADD_PREFIX(inflateCopy)
#  define inflateEnd            Z_ADD_PREFIX(inflateEnd)
#  define inflateGetDictionary  Z_ADD_PREFIX(inflateGetDictionary)
#  define inflateGetHeader      Z_ADD_PREFIX(inflateGetHeader)
#  define inflateInit           Z_ADD_PREFIX_STD(inflateInit)
#  define inflateInit2          Z_ADD_PREFIX_STD(inflateInit2)
#  define inflateInit2_         Z_ADD_PREFIX(inflateInit2_)
#  define inflateInit_          Z_ADD_PREFIX(inflateInit_)
#  define inflateMark           Z_ADD_PREFIX(inflateMark)
#  define inflatePrime          Z_ADD_PREFIX(inflatePrime)
#  define inflateReset          Z_ADD_PREFIX(inflateReset)
#  define inflateReset2         Z_ADD_PREFIX(inflateReset2)
#  define inflateResetKeep      Z_ADD_PREFIX(inflateResetKeep)
#  define inflateSetDictionary  Z_ADD_PREFIX(inflateSetDictionary)
#  define inflateSync           Z_ADD_PREFIX(inflateSync)
#  define inflateSyncPoint      Z_ADD_PREFIX(inflateSyncPoint)
#  define inflateUndermine      Z_ADD_PREFIX(inflateUndermine)
#  define inflateValidate       Z_ADD_PREFIX(inflateValidate)
#  define inflate_copyright     Z_ADD_PREFIX(inflate_copyright)
#  define inflate_fast          Z_ADD_PREFIX(inflate_fast)
#  define inflate_table         Z_ADD_PREFIX(inflate_table)
#  ifndef Z_SOLO
#    define uncompress            Z_ADD_PREFIX(uncompress)
#    define uncompress2           Z_ADD_PREFIX(uncompress2)
#  endif
#  define zError                Z_ADD_PREFIX(zError)
#  ifndef Z_SOLO
#    define zcalloc               Z_ADD_PREFIX(zcalloc)
#    define zcfree                Z_ADD_PREFIX(zcfree)
#  endif
#  define zlibCompileFlags      Z_ADD_PREFIX(zlibCompileFlags)
#  define zlibVersion           Z_ADD_PREFIX(zlibVersion)

/* all zlib typedefs in zlib.h and zconf.h */
#  define Byte                  Z_ADD_PREFIX(Byte)
#  define Bytef                 Z_ADD_PREFIX(Bytef)
#  define alloc_func            Z_ADD_PREFIX(alloc_func)
#  define charf                 Z_ADD_PREFIX(charf)
#  define free_func             Z_ADD_PREFIX(free_func)
#  ifndef Z_SOLO
#    define gzFile                Z_ADD_PREFIX(gzFile)
#  endif
#  define gz_header             Z_ADD_PREFIX(gz_header)
#  define gz_headerp            Z_ADD_PREFIX(gz_headerp)
#  define in_func               Z_ADD_PREFIX(in_func)
#  define intf                  Z_ADD_PREFIX(intf)
#  define out_func              Z_ADD_PREFIX(out_func)
#  define uInt                  Z_ADD_PREFIX(uInt)
#  define uIntf                 Z_ADD_PREFIX(uIntf)
#  define uLong                 Z_ADD_PREFIX(uLong)
#  define uLongf                Z_ADD_PREFIX(uLongf)
#  define voidp                 Z_ADD_PREFIX(voidp)
#  define voidpc                Z_ADD_PREFIX(voidpc)
#  define voidpf                Z_ADD_PREFIX(voidpf)

/* all zlib structs in zlib.h and zconf.h */
#  define gz_header_s           Z_ADD_PREFIX(gz_header_s)
#  define internal_state        Z_ADD_PREFIX(internal_state)

/* variable from zutil.h */
#  define z_errmsg              Z_ADD_PREFIX(z_errmsg)
#endif

#if defined(__MSDOS__) && !defined(MSDOS)
#  define MSDOS
#endif
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
#  define OS2
#endif
#if defined(_WINDOWS) && !defined(WINDOWS)
#  define WINDOWS
#endif
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
#  ifndef WIN32
#    define WIN32
#  endif
#endif
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
#    ifndef SYS16BIT
#      define SYS16BIT
#    endif
#  endif
#endif

/*
 * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
 * than 64k bytes at a time (needed on systems with 16-bit int).
 */
#ifdef SYS16BIT
#  define MAXSEG_64K
#endif
#ifdef MSDOS
#  define UNALIGNED_OK
#endif

#ifdef __STDC_VERSION__
#  ifndef STDC
#    define STDC
#  endif
#  if __STDC_VERSION__ >= 199901L
#    ifndef STDC99
#      define STDC99
#    endif
#  endif
#endif
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
#  define STDC
#endif
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
#  define STDC
#endif
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
#  define STDC
#endif
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
#  define STDC
#endif

#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
#  define STDC
#endif

#ifndef STDC
#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
#    define const       /* note: need a more gentle solution here */
#  endif
#endif

#if defined(ZLIB_CONST) && !defined(z_const)
#  define z_const const
#else
#  define z_const
#endif

#ifdef Z_SOLO
   typedef unsigned long z_size_t;
#else
#  define z_longlong long long
#  if defined(NO_SIZE_T)
     typedef unsigned NO_SIZE_T z_size_t;
#  elif defined(STDC)
#    include <stddef.h>
     typedef size_t z_size_t;
#  else
     typedef unsigned long z_size_t;
#  endif
#  undef z_longlong
#endif

/* Maximum value for memLevel in deflateInit2 */
#ifndef MAX_MEM_LEVEL
#  ifdef MAXSEG_64K
#    define MAX_MEM_LEVEL 8
#  else
#    define MAX_MEM_LEVEL 9
#  endif
#endif

/* Maximum value for windowBits in deflateInit2 and inflateInit2.
 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
 * created by gzip. (Files created by minigzip can still be extracted by
 * gzip.)
 */
#ifndef MAX_WBITS
#  define MAX_WBITS   15 /* 32K LZ77 window */
#endif

/* The memory requirements for deflate are (in bytes):
            (1 << (windowBits+2)) +  (1 << (memLevel+9))
 that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
 plus a few kilobytes for small objects. For example, if you want to reduce
 the default memory requirements from 256K to 128K, compile with
     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
 Of course this will generally degrade compression (there's no free lunch).

   The memory requirements for inflate are (in bytes) 1 << windowBits
 that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
 for small objects.
*/

                        /* Type declarations */

#ifndef OF /* function prototypes */
#  ifdef STDC
#    define OF(args)  args
#  else
#    define OF(args)  ()
#  endif
#endif

#ifndef Z_ARG /* function prototypes for stdarg */
#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
#    define Z_ARG(args)  args
#  else
#    define Z_ARG(args)  ()
#  endif
#endif

/* The following definitions for FAR are needed only for MSDOS mixed
 * model programming (small or medium model with some far allocations).
 * This was tested only with MSC; for other MSDOS compilers you may have
 * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
 * just define FAR to be empty.
 */
#ifdef SYS16BIT
#  if defined(M_I86SM) || defined(M_I86MM)
     /* MSC small or medium model */
#    define SMALL_MEDIUM
#    ifdef _MSC_VER
#      define FAR _far
#    else
#      define FAR far
#    endif
#  endif
#  if (defined(__SMALL__) || defined(__MEDIUM__))
     /* Turbo C small or medium model */
#    define SMALL_MEDIUM
#    ifdef __BORLANDC__
#      define FAR _far
#    else
#      define FAR far
#    endif
#  endif
#endif

#if defined(WINDOWS) || defined(WIN32)
   /* If building or using zlib as a DLL, define ZLIB_DLL.
    * This is not mandatory, but it offers a little performance increase.
    */
#  ifdef ZLIB_DLL
#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
#      ifdef ZLIB_INTERNAL
#        define ZEXTERN extern __declspec(dllexport)
#      else
#        define ZEXTERN extern __declspec(dllimport)
#      endif
#    endif
#  endif  /* ZLIB_DLL */
   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
    * define ZLIB_WINAPI.
    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
    */
#  ifdef ZLIB_WINAPI
#    ifdef FAR
#      undef FAR
#    endif
#    include <windows.h>
     /* No need for _export, use ZLIB.DEF instead. */
     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
#    define ZEXPORT WINAPI
#    ifdef WIN32
#      define ZEXPORTVA WINAPIV
#    else
#      define ZEXPORTVA FAR CDECL
#    endif
#  endif
#endif

#if defined (__BEOS__)
#  ifdef ZLIB_DLL
#    ifdef ZLIB_INTERNAL
#      define ZEXPORT   __declspec(dllexport)
#      define ZEXPORTVA __declspec(dllexport)
#    else
#      define ZEXPORT   __declspec(dllimport)
#      define ZEXPORTVA __declspec(dllimport)
#    endif
#  endif
#endif

#ifndef ZEXTERN
#  define ZEXTERN extern
#endif
#ifndef ZEXPORT
#  define ZEXPORT
#endif
#ifndef ZEXPORTVA
#  define ZEXPORTVA
#endif

#ifndef FAR
#  define FAR
#endif

#if !defined(__MACTYPES__)
typedef unsigned char  Byte;  /* 8 bits */
#endif
typedef unsigned int   uInt;  /* 16 bits or more */
typedef unsigned long  uLong; /* 32 bits or more */

#ifdef SMALL_MEDIUM
   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
#  define Bytef Byte FAR
#else
   typedef Byte  FAR Bytef;
#endif
typedef char  FAR charf;
typedef int   FAR intf;
typedef uInt  FAR uIntf;
typedef uLong FAR uLongf;

#ifdef STDC
   typedef void const *voidpc;
   typedef void FAR   *voidpf;
   typedef void       *voidp;
#else
   typedef Byte const *voidpc;
   typedef Byte FAR   *voidpf;
   typedef Byte       *voidp;
#endif

#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
#  include <limits.h>
#  if (UINT_MAX == 0xffffffffUL)
#    define Z_U4 unsigned
#  elif (ULONG_MAX == 0xffffffffUL)
#    define Z_U4 unsigned long
#  elif (USHRT_MAX == 0xffffffffUL)
#    define Z_U4 unsigned short
#  endif
#endif

#ifdef Z_U4
   typedef Z_U4 z_crc_t;
#else
   typedef unsigned long z_crc_t;
#endif

#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
#  define Z_HAVE_UNISTD_H
#endif

#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
#  define Z_HAVE_STDARG_H
#endif

#ifdef STDC
#  ifndef Z_SOLO
#    include <sys/types.h>      /* for off_t */
#  endif
#endif

#if defined(STDC) || defined(Z_HAVE_STDARG_H)
#  ifndef Z_SOLO
#    include <stdarg.h>         /* for va_list */
#  endif
#endif

#ifdef _WIN32
#  ifndef Z_SOLO
#    include <stddef.h>         /* for wchar_t */
#  endif
#endif

/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
 * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
 * though the former does not conform to the LFS document), but considering
 * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
 * equivalently requesting no 64-bit operations
 */
#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
#  undef _LARGEFILE64_SOURCE
#endif

#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
#  define Z_HAVE_UNISTD_H
#endif
#ifndef Z_SOLO
#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
#    ifdef VMS
#      include <unixio.h>       /* for off_t */
#    endif
#    ifndef z_off_t
#      define z_off_t off_t
#    endif
#  endif
#endif

#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
#  define Z_LFS64
#endif

#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
#  define Z_LARGE64
#endif

#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
#  define Z_WANT64
#endif

#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) && defined(Z_PREFIX_)
/*
 * It turns out that some of the functions defined above using custom prefix
 * will actually be macros in this library build, so they must use standard
 * prefix instead. Ugly, but we need to redefine them as we couldn't define
 * them correctly from the beginning as Z_WANT64 wasn't available then yet.
 */
#  undef adler32_combine
#  define adler32_combine       Z_ADD_PREFIX_STD(adler32_combine)
#  undef crc32_combine
#  define crc32_combine         Z_ADD_PREFIX_STD(crc32_combine)
#  ifndef Z_SOLO
#    undef gzoffset
#    define gzoffset              Z_ADD_PREFIX_STD(gzoffset)
#    undef gzopen
#    define gzopen                Z_ADD_PREFIX_STD(gzopen)
#    undef gzseek
#    define gzseek                Z_ADD_PREFIX_STD(gzseek)
#    undef gztell
#    define gztell                Z_ADD_PREFIX_STD(gztell)
#  endif
#endif

#if !defined(SEEK_SET) && !defined(Z_SOLO)
#  define SEEK_SET        0       /* Seek from beginning of file.  */
#  define SEEK_CUR        1       /* Seek from current position.  */
#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
#endif

#ifndef z_off_t
#  define z_off_t long
#endif

#if !defined(_WIN32) && defined(Z_LARGE64)
#  define z_off64_t off64_t
#else
#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
#    define z_off64_t __int64
#  else
#    define z_off64_t z_off_t
#  endif
#endif

/* MVS linker does not support external names larger than 8 bytes */
#if defined(__MVS__)
  #pragma map(deflateInit_,"DEIN")
  #pragma map(deflateInit2_,"DEIN2")
  #pragma map(deflateEnd,"DEEND")
  #pragma map(deflateBound,"DEBND")
  #pragma map(inflateInit_,"ININ")
  #pragma map(inflateInit2_,"ININ2")
  #pragma map(inflateEnd,"INEND")
  #pragma map(inflateSync,"INSY")
  #pragma map(inflateSetDictionary,"INSEDI")
  #pragma map(compressBound,"CMBND")
  #pragma map(inflate_table,"INTABL")
  #pragma map(inflate_fast,"INFA")
  #pragma map(inflate_copyright,"INCOPY")
#endif

#endif /* ZCONF_H */


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.synckware.navegador.PrincipalActivity">

    <EditText
        android:id="@+id/txtUrl"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Ex: Receita de Pizza" />

    <Button
        android:id="@+id/btnCarregar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Carregar" />

    <WebView
        android:id="@+id/webview"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>


text:
from __future__ import unicode_literals

import fnmatch
import importlib
import logging
import argparse
import os
import shutil
import sys

from unittest.runner import _WritelnDecorator as WriteLnDecorator

import django

from django.apps import AppConfig, apps
from django.conf import settings
from django.test.testcases import TransactionTestCase, TestCase
from django.utils import six

class TestProgram(object):

    def __init__(self, workingDir, tempDir, templatesDir='templates',
                 subdirsToSkip=(), alwaysInstalledApps=(),
                 alwaysMiddlwareClasses=(), stream=None):

        if stream is None:
            stream = sys.stderr

        if not isinstance(stream, WriteLnDecorator):
            stream = WriteLnDecorator(stream)

        self.alwaysInstalledApps = alwaysInstalledApps
        self.alwaysMiddlwareClasses = alwaysMiddlwareClasses
        self.plugins = self.loadPlugins()
        self.stream = stream
        self.subdirsToSkip = subdirsToSkip
        self.tempDir = tempDir
        self.templatesDir = templatesDir
        self.workingDir = workingDir

    def arguments(self, parser):
        parser.add_argument(
            'modules', metavar='module', nargs='*',
            help='Optional path(s) to test modules; e.g. "apps" or '
                 '"apps.tests.OverridingConfigTest.test_get_class".')
        parser.add_argument(
            '-v', '--verbosity', action='store', dest='verbosity', default=1,
            type=int, choices=[0, 1, 2, 3],
            help='Verbosity level: 0=minimal output, 1=normal output, 2=all '
                 'output')
        parser.add_argument(
            '-e', '--exclude', action='append', dest='exclude',
            help='Exclude tests whose label matches the given pattern.')
        parser.add_argument(
            '--noinput', action='store_false', dest='interactive', default=True,
            help='Whether NOT prompt the user for input of any kind.')
        parser.add_argument(
            '--failfast', action='store_true', dest='failfast', default=False,
            help='Whether stop running the test suite after first failed test.')
        parser.add_argument(
            '-k', '--keepdb', action='store_true', dest='keepdb', default=False,
            help='Tells Django to preserve the test database between runs.')
        parser.add_argument(
            '--settings',
            help='Python path to settings module, e.g. "myproject.settings". If '
                 'this isn\'t provided, the DJANGO_SETTINGS_MODULE environment '
                 'variable will be used.')
        parser.add_argument(
            '--reverse', action='store_true', default=False,
            help='Sort test suites and test cases in opposite order to debug '
                 'test side effects not apparent with normal execution lineup.')

    def configurePlugins(self, options):
        """
        Configure the plugin and system, based on selected options.

        The base plugin class sets the plugin to enabled if the enable
        option for the plugin (self.enableOpt) is true.

        """
        for plugin in self.plugins:
            try:
                configure = getattr(plugin, 'configure')
            except AttributeError:
                continue
            else:
                configure(options, self.stream)

    def getAvailableTestLabels(self):
        modules = [
            dirName
            for dirName
            in os.listdir(self.workingDir)
            if ('.' not in dirName
                    and os.path.basename(dirName) not in self.subdirsToSkip
                    and not os.path.isfile(dirName)
                    and os.path.exists(os.path.join(self.workingDir, dirName, '__init__.py')))
        ]
        modules.sort()
        return modules

    def getTestDiscover(self):
        from yepes.test.discover import TestDiscover
        return TestDiscover

    def getTestLabels(self, testLabels, options):
        availableTestLabels = self.getAvailableTestLabels()

        excludedTestLabels = set()
        if options.exclude:
            for pattern in options.exclude:
                foundLabels = fnmatch.filter(availableTestLabels, pattern)
                if not foundLabels:
                    msg = "Failed to find test matching '{0}'"
                    raise AttributeError(msg.format(pattern))

                excludedTestLabels.update(foundLabels)

        if not testLabels:
            finalTestLabels = list(
                label
                for label
                in availableTestLabels
                if label not in excludedTestLabels
            )
        else:
            finalTestLabels = list()
            for pattern in testLabels:
                if '.' in pattern:
                    pattern, path = pattern.split('.', 1)
                else:
                    path = None

                foundLabels = fnmatch.filter(availableTestLabels, pattern)
                if not foundLabels:
                    msg = "Failed to find test matching '{0}'"
                    raise AttributeError(msg.format(pattern))

                finalTestLabels.extend(
                    label if path is None else '.'.join((label, path))
                    for label
                    in foundLabels
                    if label not in excludedTestLabels
                )

        return finalTestLabels

    def loadPlugins(self):
        plugins = []
        try:
            from yepes.test.plugins import sugar
        except ImportError:
            pass
        else:
            plugins.append(sugar.Sugar())
        try:
            from yepes.test.plugins import xunit
        except ImportError:
            pass
        else:
            plugins.append(xunit.Xunit())
        try:
            from yepes.test.plugins import coverage
        except ImportError:
            pass
        else:
            plugins.append(coverage.Coverage())

        return plugins

    def makeParser(self):
        usage = '%prog [options] [module module module ...]'
        parser = argparse.ArgumentParser(usage=usage)
        self.arguments(parser)
        for plugin in self.plugins:
            try:
                addArguments = plugin.addArguments
            except AttributeError:
                continue
            else:
                addArguments(parser)

        return parser

    def parseArgs(self, parser):
        args = parser.parse_args()
        if args.settings:
            os.environ['DJANGO_SETTINGS_MODULE'] = args.settings
        else:
            if 'DJANGO_SETTINGS_MODULE' not in os.environ:
                os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'

            args.settings = os.environ['DJANGO_SETTINGS_MODULE']

        os.environ['DJANGO_TEST_TEMP_DIR'] = self.tempDir
        return args

    def removeTempDir(self):
        """
        Removes the temporary directory.
        """
        try:
            # Ensure we pass in unicode so that it will successfully remove
            # temp trees containing non-ASCII filenames on Windows. (We're
            # assuming the temp dir name itself does not contain non-ASCII
            # characters.)
            shutil.rmtree(six.text_type(self.tempDir))
        except OSError:
            msg = 'Failed to remove temp directory: {0}'
            self.stream.writeln(msg.format(self.tempDir))

    def restoreSettings(self, settings, old_state):
        """
        Restores the settings to its old state.
        """
        for key, value in six.iteritems(old_state):
            setattr(settings, key, value)

    def run(self):
        parser = self.makeParser()
        options = self.parseArgs(parser)
        testLabels = options.modules
        self.configurePlugins(options)
        return self.runTests(testLabels, options)

    def runTests(self, testLabels, options):
        verbosity = int(options.verbosity)
        finalTestLabels = self.getTestLabels(testLabels, options)
        state = self.setup(verbosity, finalTestLabels)

        TestDiscover = self.getTestDiscover()
        failureCount = TestDiscover(
            verbosity=verbosity,
            interactive=options.interactive,
            failfast=options.failfast,
            keepdb=options.keepdb,
            reverse=options.reverse,
            plugins=self.plugins,
            stream=self.stream,
        ).run_tests(finalTestLabels)

        self.teardown(state)
        return failureCount

    def prepareSettings(self, settings):
        """
        Overwrites some settings for the duration of these tests.
        """
        state = {
            'INSTALLED_APPS': settings.INSTALLED_APPS,
            'ROOT_URLCONF': getattr(settings, 'ROOT_URLCONF', ''),
            'TEMPLATES': settings.TEMPLATES,
            'LANGUAGE_CODE': settings.LANGUAGE_CODE,
            'STATIC_URL': settings.STATIC_URL,
            'STATIC_ROOT': settings.STATIC_ROOT,
            'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES,
        }
        settings.INSTALLED_APPS = self.alwaysInstalledApps
        settings.ROOT_URLCONF = 'urls'
        settings.STATIC_URL = '/static/'
        settings.STATIC_ROOT = os.path.join(self.tempDir, 'static')
        settings.TEMPLATES = [{
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [os.path.join(self.workingDir, self.templatesDir)],
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ],
            },
        }]
        settings.LANGUAGE_CODE = 'en'
        settings.SITE_ID = 1
        settings.MIDDLEWARE_CLASSES = self.alwaysMiddlwareClasses
        # Ensure the middleware classes are seen as overridden otherwise we
        # get a compatibility warning.
        settings._explicit_settings.add('MIDDLEWARE_CLASSES')

        return state

    def setup(self, verbosity, testLabels):
        # Force declaring available_apps in TransactionTestCase for faster
        # tests.
        def noAvailableApps(self):
            raise Exception('Please define available_apps in'
                            ' TransactionTestCase and its subclasses.')
        TransactionTestCase.available_apps = property(noAvailableApps)
        TestCase.available_apps = None

        state = self.prepareSettings(settings)

        if verbosity > 0:
            # Ensure any warnings captured to logging are piped through a
            # verbose logging handler. If any -W options were passed
            # explicitly  on command line, warnings are not captured, and
            # this has no effect.
            logger = logging.getLogger('py.warnings')
            handler = logging.StreamHandler()
            logger.addHandler(handler)

        # Load all the self.alwaysInstalledApps.
        django.setup()

        # Reduce given test labels to just the app module path
        appNames = set(l.split('.', 1)[0] for l in testLabels)

        # Load all the test model apps.
        if verbosity >= 2:
            self.stream.writeln('Importing applications ...')

        for name in appNames:
            if verbosity >= 2:
                self.stream.writeln('Importing application {0}'.format(name))

            module = importlib.import_module(name)
            config = AppConfig(name, module)
            config.label = '_'.join((config.label.strip('_'), 'tests'))
            settings.INSTALLED_APPS.append(config)

        apps.set_installed_apps(settings.INSTALLED_APPS)

        return state

    def teardown(self, state):
        self.removeTempDir()
        self.restoreSettings(settings, state)


text:
This directory contains configuration files for running Syncthing under the
"systemd" service manager on Linux both under either a systemd system service or
systemd user service. For further documentation take a look at the [systemd
section][1] on https://docs.syncthing.net.

[1]: https://docs.syncthing.net/users/autostart.html#systemd


text:
namespace Packets
{
    class CGStallDefaultPage : public Packet
    {
    public:
        enum
        {
            SAVE_MONEY = 0,
            PUTOUT_MONEY,
            UPDATE_MONEY,
        };
    public:
        CGStallDefaultPage( )
        {
            m_DefaultPage        = 0;//0:Item,2:Pet
        };
        virtual ~CGStallDefaultPage( ){};

        //公用继承接口
        virtual BOOL            Read( SocketInputStream& iStream ) ;
        virtual BOOL            Write( SocketOutputStream& oStream )const ;
        virtual UINT            Execute( Player* pPlayer ) ;

        virtual PacketID_t        GetPacketID()const { return PACKET_CG_STALL_DEFAULT_PAGE; }
        virtual UINT            GetPacketSize()const { return    sizeof(BYTE);}

    public:

        BYTE                    GetDefaultPage(VOID) const {return m_DefaultPage;};
        VOID                    SetDefaultPage(BYTE DefaultPage) {m_DefaultPage = DefaultPage;};

    private:
        BYTE                    m_DefaultPage;
    };

    class CGStallDefaultPageFactory : public PacketFactory
    {
    public:
        Packet*        CreatePacket() { return new CGStallDefaultPage() ; }
        PacketID_t    GetPacketID()const { return PACKET_CG_STALL_DEFAULT_PAGE; };
        UINT        GetPacketMaxSize()const { return sizeof(BYTE);};
    };

    class CGStallDefaultPageHandler
    {
    public:
        static UINT Execute( CGStallDefaultPage* pPacket, Player* pPlayer ) ;
    };
}

using namespace Packets;

#endif


text:
import { NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';

import { Module83RoutingModule } from './module-83-routing.module';
import { Module83CompComponent } from './components/module-83-comp/module-83-comp.component';

@NgModule({
  imports: [
    CommonModule,
    Module83RoutingModule
  ],
  declarations: [Module83CompComponent]
})
export class Module83Module { }


text:
package ras;

public enum ResourceAcquisitionState {
    Locked, Unlocked
}


text:
package org.schema.api.model.thing.medicalEntity.medicalProcedure.therapeuticProcedure.medicalTherapy;

public class OccupationalTherapy extends MedicalTherapy
{
}