text:
package org.rapidpm.ddi;

import com.vaadin.annotations.Theme;
import com.vaadin.server.VaadinRequest;
import com.vaadin.server.VaadinSession;
import com.vaadin.ui.*;
import org.rapidpm.ddi.metrics.Metrics;
import org.rapidpm.ddi.services.Service;
import org.rapidpm.ddi.vaadin.SessionUtils;

import javax.inject.Inject;
import java.time.LocalDateTime;

/**
 *
 */
@Theme("valo")
public class MyUI extends UI {

  @Inject Service service;

  public MyUI() {
    System.out.println("MyUI() - LocalDateTime.now() = " + LocalDateTime.now());
  }

  public MyUI(final Component content) {
    super(content);
    System.out.println("MyUI(content) - LocalDateTime.now() = " + LocalDateTime.now());
  }

  @Override
  protected void init(VaadinRequest vaadinRequest) {

    new SessionUtils().printSessionAttributes();

//    final Collection<URL> urlsWebInfLib = ClasspathHelper.forWebInfLib(servletContext);
//    final Iterator<URL> iterator = urlsWebInfLib.iterator();
//    while (iterator.hasNext()) {
//      URL next = iterator.next();
//      if ( ! next.toString().contains("rapidpm")) iterator.remove();
//    }
//    DI.activatePackages("org.rapidpm", urlsWebInfLib);

    DI.activatePackages("org.rapidpm");
    //inject
    DI.activateDI(this);

    final VerticalLayout layout = new VerticalLayout();
    layout.setMargin(true);
    setContent(layout);

    Button button = new Button("Click Me");
    button.addClickListener(event -> {
      final String doWork = service.doWork();
      layout.addComponent(new Label("Thank you for clicking " + doWork));
      new SessionUtils().printSessionAttributes();
      final VaadinSession session = VaadinSession.getCurrent();
      Metrics.getInstance().data.add(new Metrics.KeyValue().key("timestamp").value(doWork));
      session.setAttribute("timestamp", doWork);
    });
    layout.addComponent(button);

  }

}


text:
module Virtus

  # Include this Module for Value Object semantics
  #
  # The idea is that instances should be immutable and compared based on state
  #   (rather than identity, as is typically the case)
  #
  # @example
  #   class GeoLocation
  #     include Virtus::ValueObject
  #     attribute :latitude,  Float
  #     attribute :longitude, Float
  #   end
  #
  #   location = GeoLocation.new(:latitude => 10, :longitude => 100)
  #   same_location = GeoLocation.new(:latitude => 10, :longitude => 100)
  #   location == same_location       #=> true
  #   hash = { location => :foo }
  #   hash[same_location]             #=> :foo
  module ValueObject

    # Callback to configure including Class as a Value Object
    #
    # Including Class will include Virtus and have additional
    #   value object semantics defined in this module
    #
    # @return [Undefined]
    #
    # TODO: stacking modules is getting painful
    #   time for Facets' module_inheritance, ActiveSupport::Concern or the like
    #
    # @api private
    def self.included(base)
      base.instance_eval do
        include ::Virtus
        include InstanceMethods
        extend ClassMethods
        private :attributes=
      end
    end

    private_class_method :included

    module InstanceMethods

      # the #get_attributes method accept a Proc object that will filter
      # out an attribute when the block returns false. the ValueObject
      # needs all the attributes, so we allow every attribute.
      FILTER_NONE = proc { true }

      def initialize(attributes = {})
        set_attributes(attributes)
      end

      def with(attribute_updates)
        self.class.new(get_attributes(&FILTER_NONE).merge(attribute_updates))
      end

      # ValueObjects are immutable and can't be cloned
      #
      # They always represent the same value
      #
      # @example
      #
      #   value_object.clone === value_object # => true
      #
      # @return [self]
      #
      # @api public
      def clone
        self
      end
      alias dup clone

    end

    module ClassMethods

      # Define an attribute on the receiver
      #
      # The Attribute will have private writer methods (eg., immutable instances)
      #   and be used in equality/equivalence comparisons
      #
      # @example
      #   class GeoLocation
      #     include Virtus::ValueObject
      #
      #     attribute :latitude,  Float
      #     attribute :longitude, Float
      #   end
      #
      # @see Virtus::ClassMethods.attribute
      #
      # @return [self]
      #
      # @api public
      def attribute(name, *args)
        equalizer << name
        options = args.last.kind_of?(Hash) ? args.pop : {}
        super name, *args << options.merge(:writer => :private)
      end

      # Define and include a module that provides Value Object semantics
      #
      # Included module will have #inspect, #eql?, #== and #hash
      # methods whose definition is based on the _keys_ argument
      #
      # @example
      #   virtus_class.equalizer
      #
      # @return [Equalizer]
      #   An Equalizer module which defines #inspect, #eql?, #== and #hash
      #   for instances of this class
      #
      # @api public
      def equalizer
        @equalizer ||=
          begin
            equalizer = Equalizer.new(name || inspect)
            include equalizer
            equalizer
          end
      end

      # The list of writer methods that can be mass-assigned to in #attributes=
      #
      # @return [Set]
      #
      # @api private
      def allowed_writer_methods
        @allowed_writer_methods ||=
          begin
            allowed_writer_methods = super
            allowed_writer_methods += attribute_set.map{|attr| "#{attr.name}="}
            allowed_writer_methods.to_set.freeze
          end
      end

    end # module ClassMethods
  end # module ValueObject
end # module Virtus

redpajama_set_name: RedPajamaGithub


text:
namespace notifier {

WeakXmppClient::WeakXmppClient(jingle_xmpp::TaskParent* parent)
    : jingle_xmpp::XmppClient(parent) {}

WeakXmppClient::~WeakXmppClient() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  Invalidate();
}

void WeakXmppClient::Invalidate() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  // We don't want XmppClient raising any signals once its invalidated.
  SignalStateChange.disconnect_all();
  SignalLogInput.disconnect_all();
  SignalLogOutput.disconnect_all();
  weak_ptr_factory_.InvalidateWeakPtrs();
}

base::WeakPtr<WeakXmppClient> WeakXmppClient::AsWeakPtr() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  return weak_ptr_factory_.GetWeakPtr();
}

void WeakXmppClient::Stop() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  // We don't want XmppClient used after it has been stopped.
  Invalidate();
  jingle_xmpp::XmppClient::Stop();
}

}  // namespace notifier


text:
<?xml version='1.0' ?>

<t:chloe xmlns:t="http://factorcode.org/chloe/1.0">
	<t:title>Mason dashboard</t:title>

Crashed build machines

Machines which are not sending heartbeats:

	<t:xml t:name="crashed" />

Broken build machines

Machines with failing builds:

	<t:xml t:name="broken" />

Force build now

Requires build engineer status.

	<t:form t:action="$mason-app/dashboard/increment-counter">

<button type="submit">Increment counter</button>

	</t:form>

Make a release

Requires build engineer status.

	<t:form t:action="$mason-app/dashboard/make-release">

Version:	<t:field t:name="version" />

Announcement URL:	<t:field t:name="announcement-url" />

<button type="submit">Go</button>

	</t:form>
</t:chloe>


text:
package org.apache.hadoop.hbase.chaos.actions;

import java.io.IOException;
import java.util.Random;

import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * Action that changes the number of versions on a column family from a list of tables.
 *
 * Always keeps at least 1 as the number of versions.
 */
public class ChangeVersionsAction extends Action {
  private final byte[] tableName;
  private final String tableNameString;

  private HBaseAdmin admin;
  private Random random;

  public ChangeVersionsAction(String tableName) {
    tableNameString = tableName;
    this.tableName = Bytes.toBytes(tableName);
    this.random = new Random();
  }

  @Override
  public void init(ActionContext context) throws IOException {
    super.init(context);
    this.admin = context.getHBaseIntegrationTestingUtility().getHBaseAdmin();
  }

  @Override
  public void perform() throws Exception {
    HTableDescriptor tableDescriptor = admin.getTableDescriptor(tableName);
    HColumnDescriptor[] columnDescriptors = tableDescriptor.getColumnFamilies();

    if ( columnDescriptors == null || columnDescriptors.length == 0) {
      return;
    }

    int versions =  random.nextInt(3) + 1;
    for(HColumnDescriptor descriptor:columnDescriptors) {
      descriptor.setMaxVersions(versions);
      descriptor.setMinVersions(versions);
    }
    LOG.debug("Performing action: Changing versions on " + tableNameString);
    admin.modifyTable(tableName, tableDescriptor);
  }
}


text:
<?php
/* @var $this SmsController */
/* @var $model Sms */

$this->breadcrumbs=array(
	'Sms'=>array('index'),
	'Manage',
);

$this->menu=array(
	array('label'=>'List Sms', 'url'=>array('index')),
	array('label'=>'Create Sms', 'url'=>array('create')),
);

Yii::app()->clientScript->registerScript('search', "
$('.search-button').click(function(){
	$('.search-form').toggle();
	return false;
});
$('.search-form form').submit(function(){
	$('#sms-grid').yiiGridView('update', {
		data: $(this).serialize()
	});
	return false;
});
");
?>

Manage Sms

You may optionally enter a comparison operator (<, <=, >, >=, <>
or =) at the beginning of each of your search values to specify how the comparison should be done.

<?php echo CHtml::link('Advanced Search','#',array('class'=>'search-button')); ?>

<?php $this->renderPartial('_search',array(
	'model'=>$model,
)); ?>

<?php $this->widget('zii.widgets.grid.CGridView', array(
	'id'=>'sms-grid',
	'dataProvider'=>$model->search(),
	'filter'=>$model,
	'columns'=>array(
		'id',
		'address',
		'datehandle',
		'read',
		'type',
		'body',
		/*
		'seen',
		*/
		array(
			'class'=>'CButtonColumn',
		),
	),
)); ?>


text:
<?php

 	$t_order = $this->getVar('t_order');
	$vn_order_id = $this->getVar('order_id');
?>
<div class="sectionBox">
<?php
	if (!$this->getVar('confirmed')) {
		// show delete confirmation notice
		print caDeleteWarningBox($this->request, $t_order, _t('order'), 'client/library', 'OrderEditor', 'CustomerInfo', array('order_id' => $vn_order_id));
	}
?>
</div>


text:
//////////////////////////////////////////////////////////////////////////////
//
//                    Copyright 2020, Cornutum Project
//                             www.cornutum.org
//
//////////////////////////////////////////////////////////////////////////////

package org.cornutum.tcases.openapi.resolver;

import org.cornutum.tcases.openapi.resolver.io.RequestTestDefReader;
import org.cornutum.tcases.openapi.resolver.io.RequestTestDefWriter;

import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runners.Parameterized;
import static org.apache.commons.lang3.StringUtils.trimToNull;
import static org.cornutum.hamcrest.Composites.*;
import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Optional;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toList;

/**
 * Runs tests for {@link RequestCases#realizeRequestCases}.
 */
@RunWith(Parameterized.class)
public class RealizeTest extends RequestCaseTest
  {
  @Parameters(name = "{0}")
  public static Iterable<Object[]> requestCases()
    {
    return getRequestCaseParams( new String[]{ "petstore-requests", "realize", "normalize"});
    }

  private static Iterable<Object[]> getRequestCaseParams( String[] groups)
    {
    return
      Arrays.stream( groups)
      .flatMap( prefix -> getRequestCaseBaseNames( prefix))
      .map( baseName -> new Object[]{ baseName })
      .collect( toList());
    }

  /**
   * Returns base names for all test resources with the given prefix.
   */
  private static Stream<String> getRequestCaseBaseNames( String prefix)
    {
    return
      getRequestCaseResources( prefix)
      .map( RealizeTest::getRequestCaseBaseName)
      .sorted();
    }

  /**
   * Returns all test resources with the given base name.
   */
  private static Stream<File> getRequestCaseResources( String baseName)
    {
    String testBaseName = trimToNull( System.getProperty( "testBaseName"));

    return
      testBaseName == null?
      Arrays.stream( getRequestCasesDir().listFiles( baseNameRequestCases( baseName))) :

      testBaseName.startsWith( baseName)?
      Arrays.stream( getRequestCasesDir().listFiles( baseNameRequestCases( testBaseName))) :

      Stream.empty();
    }

  /**
   * Returns the base name of the given request test definition file.
   */
  private static String getRequestCaseBaseName( File testDefFile)
    {
    return testDefFile.getName().replaceAll( requestCasesSuffix_, "");
    }

  /**
   * Returns a filter that matches all test resources with the given base name.
   */
  private static FilenameFilter baseNameRequestCases( String baseName)
    {
    return
      FileFilterUtils.and(
        FileFilterUtils.prefixFileFilter( baseName),
        FileFilterUtils.suffixFileFilter( requestCasesSuffix_));
    }

  /**
   * Returns the location of the resource files for this class.
   */
  private static File getRequestCasesDir()
    {
    try
      {
      return new File( RealizeTest.class.getResource( ".").toURI().getPath());
      }
    catch( Exception e)
      {
      throw new RuntimeException( "Can't get resource directory path", e);
      }
    }

  /**
   * Creates a new RealizeTest instance.
   */
  public RealizeTest( String testDefBase)
    {
    testDefBase_ = testDefBase;
    }

  @Test
  public void verifyRealized()
    {
    // Given...
    RequestTestDef requestTestDef = readRequestCases( requestCasesFor( testDefBase_));

    // When...
    RequestTestDef realized = RequestCases.realizeRequestCases( requestTestDef);

    // Then...
    verifyRealized( realized);
    }

  /**
   * Verifies that request cases match expectations.
   */
  private void verifyRealized( RequestTestDef requestTestDef)
    {
    if( acceptAsExpected())
      {
      updateRealizedCases( testDefBase_, requestTestDef);
      }
    else
      {
      assertThat(
        testDefBase_,
        requestTestDef.getRequestCases(),
        listsMembers( RequestCaseMatcher::new, readRequestCases( realizedCasesFor( testDefBase_)).getRequestCases()));
      }
    }

  /**
   * Returns the {@link RequestCase} objects represented by the given document resource.
   */
  protected RequestTestDef readRequestCases( String resource)
    {
    InputStream document = getClass().getResourceAsStream( resource);
    assertThat( "Request cases " + resource, document, is( notNullValue()));

    try( RequestTestDefReader reader = new RequestTestDefReader( document))
      {
      return reader.getRequestTestDef();
      }
    }

  /**
   * Updates the given {@link RequestCase} resource.
   */
  private void updateRealizedCases( String baseName, RequestTestDef requestTestDef)
    {
    File requestCaseFile = new File( saveExpectedDir_, realizedCasesFor( baseName));
    try( RequestTestDefWriter writer = new RequestTestDefWriter( new FileOutputStream( requestCaseFile)))
      {
      writer.write( requestTestDef);
      }
    catch( Exception e)
      {
      throw new RequestCaseException( String.format( "Can't write request cases to file=%s", requestCaseFile), e);
      }
    }

  /**
   * Returns the name of the request cases file with the given base name
   */
  private String requestCasesFor( String baseName)
    {
    return String.format( "%s%s", baseName, requestCasesSuffix_);
    }

  /**
   * Returns the name of the realized request cases file with the given base name
   */
  private String realizedCasesFor( String baseName)
    {
    return String.format( "%s%s", baseName, realizedCasesSuffix_);
    }

  /**
   * Returns true if all generated results are automatically accepted.
   */
  private boolean acceptAsExpected()
    {
    return saveExpectedDir_ != null;
    }

  private String testDefBase_;

  private static final String requestCasesSuffix_ = "-Request-Cases.json";
  private static final String realizedCasesSuffix_ = "-Realized-Cases.json";

  private final File saveExpectedDir_ =
    Optional.ofNullable( StringUtils.trimToNull( System.getProperty( "saveExpectedTo")))
    .map( path -> new File( path))
    .orElse( null);
  }


text:
This outlines the maintainers steps to release the Jenkins Hygieia plugin.  Follow
the Jenkins documentation for [making a new release][plugin-release].

- [ ] Configure your credentials in `~/.m2/settings.xml`. (outlined in [making a
      new release][plugin-release] doc)
- [ ] Create a new issue to track the release and give it the label `maintainer
      communication`.
- [ ] Create a release branch. `git checkout origin/master -b prepare_release`
- [ ] Update the release notes in `CHANGELOG.md`.
- [ ] Open a pull request from `prepare_release` branch to `master` branch.
      Merge it.
- [ ] Fetch the latest `master`.
- [ ] Clean the workspace `git clean -xfd`.
- [ ] Execute the release plugin.

    ```
    mvn org.apache.maven.plugins:maven-release-plugin:2.5:prepare org.apache.maven.plugins:maven-release-plugin:2.5:perform
    ```

- [ ] Wait for the plugin to be released into the Jenkins Update Center.
- [ ] Successfully perform an upgrade from the last stable plugin release to the
      current release.

I pin which version of the release plugin to use because of the working around
common issues section of the [release document][plugin-release].

[plugin-release]: https://wiki.jenkins-ci.org/display/JENKINS/Hosting+Plugins


text:
package ch.ethz.inf.vs.semantics.parser.notation3;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class N3Parser extends Parser {
	static { RuntimeMetaData.checkVersion("4.3", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__15=1, T__14=2, T__13=3, T__12=4, T__11=5, T__10=6, T__9=7, T__8=8,
		T__7=9, T__6=10, T__5=11, T__4=12, T__3=13, T__2=14, T__1=15, T__0=16,
		NumericLiteral=17, BooleanLiteral=18, String=19, WS=20, COMMENT=21, PN_PREFIX=22,
		IRIREF=23, PNAME_NS=24, PrefixedName=25, PNAME_LN=26, BLANK_NODE_LABEL=27,
		LANGTAG=28, EXVAR=29, ALPHANUM=30, INTEGER=31, DECIMAL=32, DOUBLE=33,
		EXPONENT=34, STRING_LITERAL_LONG_SINGLE_QUOTE=35, STRING_LITERAL_LONG_QUOTE=36,
		STRING_LITERAL_QUOTE=37, STRING_LITERAL_SINGLE_QUOTE=38, UCHAR=39, ECHAR=40,
		ANON_WS=41, ANON=42, SC=43, PN_CHARS_BASE=44, PN_CHARS_U=45, PN_CHARS=46,
		PN_LOCAL=47, PLX=48, PERCENT=49, HEX=50, PN_LOCAL_ESC=51;
	public static final String[] tokenNames = {
		"<INVALID>", "'PREFIX'", "'['", "'^^'", "'{'", "';'", "']'", "'}'", "'=>'",
		"'a'", "'('", "')'", "'@prefix'", "','", "'BASE'", "'@base'", "'.'", "NumericLiteral",
		"BooleanLiteral", "String", "WS", "COMMENT", "PN_PREFIX", "IRIREF", "PNAME_NS",
		"PrefixedName", "PNAME_LN", "BLANK_NODE_LABEL", "LANGTAG", "EXVAR", "ALPHANUM",
		"INTEGER", "DECIMAL", "DOUBLE", "EXPONENT", "STRING_LITERAL_LONG_SINGLE_QUOTE",
		"STRING_LITERAL_LONG_QUOTE", "STRING_LITERAL_QUOTE", "STRING_LITERAL_SINGLE_QUOTE",
		"UCHAR", "ECHAR", "ANON_WS", "ANON", "SC", "PN_CHARS_BASE", "PN_CHARS_U",
		"PN_CHARS", "PN_LOCAL", "PLX", "PERCENT", "HEX", "PN_LOCAL_ESC"
	};
	public static final int
		RULE_n3Doc = 0, RULE_statements = 1, RULE_directive = 2, RULE_classification = 3,
		RULE_prefixID = 4, RULE_base = 5, RULE_triple = 6, RULE_verbObject = 7,
		RULE_verbObjectList = 8, RULE_objectList = 9, RULE_verb = 10, RULE_subject = 11,
		RULE_object = 12, RULE_formula = 13, RULE_literal = 14, RULE_blankNodePropertyList = 15,
		RULE_collection = 16, RULE_booleanLiteral = 17, RULE_iri = 18, RULE_blankNode = 19,
		RULE_exvar = 20;
	public static final String[] ruleNames = {
		"n3Doc", "statements", "directive", "classification", "prefixID", "base",
		"triple", "verbObject", "verbObjectList", "objectList", "verb", "subject",
		"object", "formula", "literal", "blankNodePropertyList", "collection",
		"booleanLiteral", "iri", "blankNode", "exvar"
	};

	@Override
	public String getGrammarFileName() { return "N3.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public N3Parser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class N3DocContext extends ParserRuleContext {
		public DirectiveContext directive(int i) {
			return getRuleContext(DirectiveContext.class,i);
		}
		public List<DirectiveContext> directive() {
			return getRuleContexts(DirectiveContext.class);
		}
		public StatementsContext statements() {
			return getRuleContext(StatementsContext.class,0);
		}
		public N3DocContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_n3Doc; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterN3Doc(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitN3Doc(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitN3Doc(this);
			else return visitor.visitChildren(this);
		}
	}

	public final N3DocContext n3Doc() throws RecognitionException {
		N3DocContext _localctx = new N3DocContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_n3Doc);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(45);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__15) | (1L << T__4) | (1L << T__2) | (1L << T__1))) != 0)) {
				{
				{
				setState(42); directive();
				}
				}
				setState(47);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(51);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__14) | (1L << T__12) | (1L << T__6) | (1L << NumericLiteral) | (1L << BooleanLiteral) | (1L << String) | (1L << IRIREF) | (1L << PrefixedName) | (1L << BLANK_NODE_LABEL) | (1L << LANGTAG) | (1L << EXVAR) | (1L << ANON))) != 0)) {
				{
				setState(48); statements();
				setState(49); match(T__0);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StatementsContext extends ParserRuleContext {
		public ExvarContext exvar() {
			return getRuleContext(ExvarContext.class,0);
		}
		public StatementsContext statements() {
			return getRuleContext(StatementsContext.class,0);
		}
		public ClassificationContext classification() {
			return getRuleContext(ClassificationContext.class,0);
		}
		public BooleanLiteralContext booleanLiteral() {
			return getRuleContext(BooleanLiteralContext.class,0);
		}
		public TripleContext triple() {
			return getRuleContext(TripleContext.class,0);
		}
		public StatementsContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statements; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterStatements(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitStatements(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitStatements(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementsContext statements() throws RecognitionException {
		StatementsContext _localctx = new StatementsContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_statements);
		try {
			setState(78);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(53); booleanLiteral();
				setState(56);
				switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
				case 1:
					{
					setState(54); match(T__0);
					setState(55); statements();
					}
					break;
				}
				setState(59);
				switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
				case 1:
					{
					setState(58); match(T__0);
					}
					break;
				}
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(61); triple();
				setState(64);
				switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
				case 1:
					{
					setState(62); match(T__0);
					setState(63); statements();
					}
					break;
				}
				setState(67);
				switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
				case 1:
					{
					setState(66); match(T__0);
					}
					break;
				}
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(69); exvar();
				setState(72);
				switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
				case 1:
					{
					setState(70); match(T__0);
					setState(71); statements();
					}
					break;
				}
				setState(75);
				switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
				case 1:
					{
					setState(74); match(T__0);
					}
					break;
				}
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(77); classification();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DirectiveContext extends ParserRuleContext {
		public BaseContext base() {
			return getRuleContext(BaseContext.class,0);
		}
		public PrefixIDContext prefixID() {
			return getRuleContext(PrefixIDContext.class,0);
		}
		public DirectiveContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_directive; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterDirective(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitDirective(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitDirective(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DirectiveContext directive() throws RecognitionException {
		DirectiveContext _localctx = new DirectiveContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_directive);
		try {
			setState(82);
			switch (_input.LA(1)) {
			case T__15:
			case T__4:
				enterOuterAlt(_localctx, 1);
				{
				setState(80); prefixID();
				}
				break;
			case T__2:
			case T__1:
				enterOuterAlt(_localctx, 2);
				{
				setState(81); base();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClassificationContext extends ParserRuleContext {
		public ObjectListContext objectList() {
			return getRuleContext(ObjectListContext.class,0);
		}
		public StatementsContext statements() {
			return getRuleContext(StatementsContext.class,0);
		}
		public TerminalNode LANGTAG() { return getToken(N3Parser.LANGTAG, 0); }
		public ClassificationContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_classification; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterClassification(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitClassification(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitClassification(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClassificationContext classification() throws RecognitionException {
		ClassificationContext _localctx = new ClassificationContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_classification);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(84); match(LANGTAG);
			setState(85); objectList();
			setState(86); match(T__0);
			setState(87); statements();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PrefixIDContext extends ParserRuleContext {
		public TerminalNode IRIREF() { return getToken(N3Parser.IRIREF, 0); }
		public TerminalNode PNAME_NS() { return getToken(N3Parser.PNAME_NS, 0); }
		public PrefixIDContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_prefixID; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterPrefixID(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitPrefixID(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitPrefixID(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PrefixIDContext prefixID() throws RecognitionException {
		PrefixIDContext _localctx = new PrefixIDContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_prefixID);
		try {
			setState(96);
			switch (_input.LA(1)) {
			case T__4:
				enterOuterAlt(_localctx, 1);
				{
				setState(89); match(T__4);
				setState(90); match(PNAME_NS);
				setState(91); match(IRIREF);
				setState(92); match(T__0);
				}
				break;
			case T__15:
				enterOuterAlt(_localctx, 2);
				{
				setState(93); match(T__15);
				setState(94); match(PNAME_NS);
				setState(95); match(IRIREF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BaseContext extends ParserRuleContext {
		public TerminalNode IRIREF() { return getToken(N3Parser.IRIREF, 0); }
		public BaseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_base; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterBase(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitBase(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitBase(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BaseContext base() throws RecognitionException {
		BaseContext _localctx = new BaseContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_base);
		try {
			setState(103);
			switch (_input.LA(1)) {
			case T__1:
				enterOuterAlt(_localctx, 1);
				{
				setState(98); match(T__1);
				setState(99); match(IRIREF);
				setState(100); match(T__0);
				}
				break;
			case T__2:
				enterOuterAlt(_localctx, 2);
				{
				setState(101); match(T__2);
				setState(102); match(IRIREF);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TripleContext extends ParserRuleContext {
		public SubjectContext subject() {
			return getRuleContext(SubjectContext.class,0);
		}
		public VerbObjectListContext verbObjectList() {
			return getRuleContext(VerbObjectListContext.class,0);
		}
		public BlankNodePropertyListContext blankNodePropertyList() {
			return getRuleContext(BlankNodePropertyListContext.class,0);
		}
		public TripleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_triple; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterTriple(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitTriple(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitTriple(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TripleContext triple() throws RecognitionException {
		TripleContext _localctx = new TripleContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_triple);
		int _la;
		try {
			setState(112);
			switch (_input.LA(1)) {
			case T__12:
			case T__6:
			case NumericLiteral:
			case BooleanLiteral:
			case String:
			case IRIREF:
			case PrefixedName:
			case BLANK_NODE_LABEL:
			case EXVAR:
			case ANON:
				enterOuterAlt(_localctx, 1);
				{
				setState(105); subject();
				setState(106); verbObjectList();
				}
				break;
			case T__14:
				enterOuterAlt(_localctx, 2);
				{
				setState(108); blankNodePropertyList();
				setState(110);
				_la = _input.LA(1);
				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__8) | (1L << T__7) | (1L << IRIREF) | (1L << PrefixedName) | (1L << BLANK_NODE_LABEL) | (1L << EXVAR))) != 0)) {
					{
					setState(109); verbObjectList();
					}
				}

				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbObjectContext extends ParserRuleContext {
		public VerbContext v;
		public ObjectListContext o;
		public ObjectListContext objectList() {
			return getRuleContext(ObjectListContext.class,0);
		}
		public VerbContext verb() {
			return getRuleContext(VerbContext.class,0);
		}
		public VerbObjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verbObject; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterVerbObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitVerbObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitVerbObject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VerbObjectContext verbObject() throws RecognitionException {
		VerbObjectContext _localctx = new VerbObjectContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_verbObject);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(114); ((VerbObjectContext)_localctx).v = verb();
			setState(115); ((VerbObjectContext)_localctx).o = objectList();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbObjectListContext extends ParserRuleContext {
		public VerbObjectContext verbObject(int i) {
			return getRuleContext(VerbObjectContext.class,i);
		}
		public List<VerbObjectContext> verbObject() {
			return getRuleContexts(VerbObjectContext.class);
		}
		public VerbObjectListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verbObjectList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterVerbObjectList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitVerbObjectList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitVerbObjectList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VerbObjectListContext verbObjectList() throws RecognitionException {
		VerbObjectListContext _localctx = new VerbObjectListContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_verbObjectList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(117); verbObject();
			setState(122);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__11) {
				{
				{
				setState(118); match(T__11);
				setState(119); verbObject();
				}
				}
				setState(124);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectListContext extends ParserRuleContext {
		public ObjectContext object(int i) {
			return getRuleContext(ObjectContext.class,i);
		}
		public List<ObjectContext> object() {
			return getRuleContexts(ObjectContext.class);
		}
		public ObjectListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_objectList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterObjectList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitObjectList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitObjectList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ObjectListContext objectList() throws RecognitionException {
		ObjectListContext _localctx = new ObjectListContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_objectList);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(125); object();
			setState(130);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==T__3) {
				{
				{
				setState(126); match(T__3);
				setState(127); object();
				}
				}
				setState(132);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class VerbContext extends ParserRuleContext {
		public TerminalNode EXVAR() { return getToken(N3Parser.EXVAR, 0); }
		public IriContext iri() {
			return getRuleContext(IriContext.class,0);
		}
		public TerminalNode BLANK_NODE_LABEL() { return getToken(N3Parser.BLANK_NODE_LABEL, 0); }
		public VerbContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verb; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterVerb(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitVerb(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitVerb(this);
			else return visitor.visitChildren(this);
		}
	}

	public final VerbContext verb() throws RecognitionException {
		VerbContext _localctx = new VerbContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_verb);
		try {
			setState(138);
			switch (_input.LA(1)) {
			case IRIREF:
			case PrefixedName:
				enterOuterAlt(_localctx, 1);
				{
				setState(133); iri();
				}
				break;
			case T__7:
				enterOuterAlt(_localctx, 2);
				{
				setState(134); match(T__7);
				}
				break;
			case T__8:
				enterOuterAlt(_localctx, 3);
				{
				setState(135); match(T__8);
				}
				break;
			case BLANK_NODE_LABEL:
				enterOuterAlt(_localctx, 4);
				{
				setState(136); match(BLANK_NODE_LABEL);
				}
				break;
			case EXVAR:
				enterOuterAlt(_localctx, 5);
				{
				setState(137); match(EXVAR);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubjectContext extends ParserRuleContext {
		public BlankNodeContext blankNode() {
			return getRuleContext(BlankNodeContext.class,0);
		}
		public ExvarContext exvar() {
			return getRuleContext(ExvarContext.class,0);
		}
		public FormulaContext formula() {
			return getRuleContext(FormulaContext.class,0);
		}
		public IriContext iri() {
			return getRuleContext(IriContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public BooleanLiteralContext booleanLiteral() {
			return getRuleContext(BooleanLiteralContext.class,0);
		}
		public CollectionContext collection() {
			return getRuleContext(CollectionContext.class,0);
		}
		public SubjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subject; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterSubject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitSubject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitSubject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SubjectContext subject() throws RecognitionException {
		SubjectContext _localctx = new SubjectContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_subject);
		try {
			setState(147);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(140); booleanLiteral();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(141); iri();
				}
				break;

			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(142); blankNode();
				}
				break;

			case 4:
				enterOuterAlt(_localctx, 4);
				{
				setState(143); collection();
				}
				break;

			case 5:
				enterOuterAlt(_localctx, 5);
				{
				setState(144); exvar();
				}
				break;

			case 6:
				enterOuterAlt(_localctx, 6);
				{
				setState(145); formula();
				}
				break;

			case 7:
				enterOuterAlt(_localctx, 7);
				{
				setState(146); literal();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ObjectContext extends ParserRuleContext {
		public BlankNodeContext blankNode() {
			return getRuleContext(BlankNodeContext.class,0);
		}
		public ExvarContext exvar() {
			return getRuleContext(ExvarContext.class,0);
		}
		public FormulaContext formula() {
			return getRuleContext(FormulaContext.class,0);
		}
		public IriContext iri() {
			return getRuleContext(IriContext.class,0);
		}
		public LiteralContext literal() {
			return getRuleContext(LiteralContext.class,0);
		}
		public CollectionContext collection() {
			return getRuleContext(CollectionContext.class,0);
		}
		public BlankNodePropertyListContext blankNodePropertyList() {
			return getRuleContext(BlankNodePropertyListContext.class,0);
		}
		public ObjectContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_object; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterObject(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitObject(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitObject(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ObjectContext object() throws RecognitionException {
		ObjectContext _localctx = new ObjectContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_object);
		try {
			setState(156);
			switch (_input.LA(1)) {
			case IRIREF:
			case PrefixedName:
				enterOuterAlt(_localctx, 1);
				{
				setState(149); iri();
				}
				break;
			case ANON:
				enterOuterAlt(_localctx, 2);
				{
				setState(150); blankNode();
				}
				break;
			case T__6:
				enterOuterAlt(_localctx, 3);
				{
				setState(151); collection();
				}
				break;
			case BLANK_NODE_LABEL:
			case EXVAR:
				enterOuterAlt(_localctx, 4);
				{
				setState(152); exvar();
				}
				break;
			case T__14:
				enterOuterAlt(_localctx, 5);
				{
				setState(153); blankNodePropertyList();
				}
				break;
			case NumericLiteral:
			case BooleanLiteral:
			case String:
				enterOuterAlt(_localctx, 6);
				{
				setState(154); literal();
				}
				break;
			case T__12:
				enterOuterAlt(_localctx, 7);
				{
				setState(155); formula();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FormulaContext extends ParserRuleContext {
		public StatementsContext statements() {
			return getRuleContext(StatementsContext.class,0);
		}
		public FormulaContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_formula; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterFormula(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitFormula(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitFormula(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FormulaContext formula() throws RecognitionException {
		FormulaContext _localctx = new FormulaContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_formula);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(158); match(T__12);
			setState(160);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__14) | (1L << T__12) | (1L << T__6) | (1L << NumericLiteral) | (1L << BooleanLiteral) | (1L << String) | (1L << IRIREF) | (1L << PrefixedName) | (1L << BLANK_NODE_LABEL) | (1L << LANGTAG) | (1L << EXVAR) | (1L << ANON))) != 0)) {
				{
				setState(159); statements();
				}
			}

			setState(162); match(T__9);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LiteralContext extends ParserRuleContext {
		public TerminalNode NumericLiteral() { return getToken(N3Parser.NumericLiteral, 0); }
		public TerminalNode String() { return getToken(N3Parser.String, 0); }
		public IriContext iri() {
			return getRuleContext(IriContext.class,0);
		}
		public TerminalNode BooleanLiteral() { return getToken(N3Parser.BooleanLiteral, 0); }
		public TerminalNode LANGTAG() { return getToken(N3Parser.LANGTAG, 0); }
		public LiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_literal; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LiteralContext literal() throws RecognitionException {
		LiteralContext _localctx = new LiteralContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_literal);
		try {
			setState(172);
			switch (_input.LA(1)) {
			case String:
				enterOuterAlt(_localctx, 1);
				{
				setState(164); match(String);
				setState(168);
				switch (_input.LA(1)) {
				case LANGTAG:
					{
					setState(165); match(LANGTAG);
					}
					break;
				case T__13:
					{
					setState(166); match(T__13);
					setState(167); iri();
					}
					break;
				case T__14:
				case T__12:
				case T__11:
				case T__10:
				case T__9:
				case T__8:
				case T__7:
				case T__6:
				case T__5:
				case T__3:
				case T__0:
				case NumericLiteral:
				case BooleanLiteral:
				case String:
				case IRIREF:
				case PrefixedName:
				case BLANK_NODE_LABEL:
				case EXVAR:
				case ANON:
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			case NumericLiteral:
				enterOuterAlt(_localctx, 2);
				{
				setState(170); match(NumericLiteral);
				}
				break;
			case BooleanLiteral:
				enterOuterAlt(_localctx, 3);
				{
				setState(171); match(BooleanLiteral);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlankNodePropertyListContext extends ParserRuleContext {
		public VerbObjectListContext verbObjectList() {
			return getRuleContext(VerbObjectListContext.class,0);
		}
		public BlankNodePropertyListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blankNodePropertyList; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterBlankNodePropertyList(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitBlankNodePropertyList(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitBlankNodePropertyList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlankNodePropertyListContext blankNodePropertyList() throws RecognitionException {
		BlankNodePropertyListContext _localctx = new BlankNodePropertyListContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_blankNodePropertyList);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(174); match(T__14);
			setState(175); verbObjectList();
			setState(176); match(T__10);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CollectionContext extends ParserRuleContext {
		public ObjectContext object(int i) {
			return getRuleContext(ObjectContext.class,i);
		}
		public List<ObjectContext> object() {
			return getRuleContexts(ObjectContext.class);
		}
		public CollectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collection; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterCollection(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitCollection(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitCollection(this);
			else return visitor.visitChildren(this);
		}
	}

	public final CollectionContext collection() throws RecognitionException {
		CollectionContext _localctx = new CollectionContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_collection);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(178); match(T__6);
			setState(182);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__14) | (1L << T__12) | (1L << T__6) | (1L << NumericLiteral) | (1L << BooleanLiteral) | (1L << String) | (1L << IRIREF) | (1L << PrefixedName) | (1L << BLANK_NODE_LABEL) | (1L << EXVAR) | (1L << ANON))) != 0)) {
				{
				{
				setState(179); object();
				}
				}
				setState(184);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(185); match(T__5);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BooleanLiteralContext extends ParserRuleContext {
		public TerminalNode BooleanLiteral() { return getToken(N3Parser.BooleanLiteral, 0); }
		public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_booleanLiteral; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterBooleanLiteral(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitBooleanLiteral(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitBooleanLiteral(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
		BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_booleanLiteral);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(187); match(BooleanLiteral);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IriContext extends ParserRuleContext {
		public TerminalNode IRIREF() { return getToken(N3Parser.IRIREF, 0); }
		public TerminalNode PrefixedName() { return getToken(N3Parser.PrefixedName, 0); }
		public IriContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_iri; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterIri(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitIri(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitIri(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IriContext iri() throws RecognitionException {
		IriContext _localctx = new IriContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_iri);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(189);
			_la = _input.LA(1);
			if ( !(_la==IRIREF || _la==PrefixedName) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlankNodeContext extends ParserRuleContext {
		public TerminalNode ANON() { return getToken(N3Parser.ANON, 0); }
		public BlankNodeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_blankNode; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterBlankNode(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitBlankNode(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitBlankNode(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlankNodeContext blankNode() throws RecognitionException {
		BlankNodeContext _localctx = new BlankNodeContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_blankNode);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(191); match(ANON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExvarContext extends ParserRuleContext {
		public TerminalNode EXVAR() { return getToken(N3Parser.EXVAR, 0); }
		public TerminalNode BLANK_NODE_LABEL() { return getToken(N3Parser.BLANK_NODE_LABEL, 0); }
		public ExvarContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_exvar; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).enterExvar(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof N3Listener ) ((N3Listener)listener).exitExvar(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof N3Visitor ) return ((N3Visitor<? extends T>)visitor).visitExvar(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExvarContext exvar() throws RecognitionException {
		ExvarContext _localctx = new ExvarContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_exvar);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(193);
			_la = _input.LA(1);
			if ( !(_la==BLANK_NODE_LABEL || _la==EXVAR) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\65\u00c6\4\2\t\2"+
		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\3\2\7\2.\n\2\f\2\16\2\61\13\2"+
		"\3\2\3\2\3\2\5\2\66\n\2\3\3\3\3\3\3\5\3;\n\3\3\3\5\3>\n\3\3\3\3\3\3\3"+
		"\5\3C\n\3\3\3\5\3F\n\3\3\3\3\3\3\3\5\3K\n\3\3\3\5\3N\n\3\3\3\5\3Q\n\3"+
		"\3\4\3\4\5\4U\n\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6"+
		"c\n\6\3\7\3\7\3\7\3\7\3\7\5\7j\n\7\3\b\3\b\3\b\3\b\3\b\5\bq\n\b\5\bs\n"+
		"\b\3\t\3\t\3\t\3\n\3\n\3\n\7\n{\n\n\f\n\16\n~\13\n\3\13\3\13\3\13\7\13"+
		"\u0083\n\13\f\13\16\13\u0086\13\13\3\f\3\f\3\f\3\f\3\f\5\f\u008d\n\f\3"+
		"\r\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u0096\n\r\3\16\3\16\3\16\3\16\3\16\3\16"+
		"\3\16\5\16\u009f\n\16\3\17\3\17\5\17\u00a3\n\17\3\17\3\17\3\20\3\20\3"+
		"\20\3\20\5\20\u00ab\n\20\3\20\3\20\5\20\u00af\n\20\3\21\3\21\3\21\3\21"+
		"\3\22\3\22\7\22\u00b7\n\22\f\22\16\22\u00ba\13\22\3\22\3\22\3\23\3\23"+
		"\3\24\3\24\3\25\3\25\3\26\3\26\3\26\2\2\27\2\4\6\b\n\f\16\20\22\24\26"+
		"\30\32\34\36 \"$&(*\2\4\4\2\31\31\33\33\4\2\35\35\37\37\u00d8\2/\3\2\2"+
		"\2\4P\3\2\2\2\6T\3\2\2\2\bV\3\2\2\2\nb\3\2\2\2\fi\3\2\2\2\16r\3\2\2\2"+
		"\20t\3\2\2\2\22w\3\2\2\2\24\177\3\2\2\2\26\u008c\3\2\2\2\30\u0095\3\2"+
		"\2\2\32\u009e\3\2\2\2\34\u00a0\3\2\2\2\36\u00ae\3\2\2\2 \u00b0\3\2\2\2"+
		"\"\u00b4\3\2\2\2$\u00bd\3\2\2\2&\u00bf\3\2\2\2(\u00c1\3\2\2\2*\u00c3\3"+
		"\2\2\2,.\5\6\4\2-,\3\2\2\2.\61\3\2\2\2/-\3\2\2\2/\60\3\2\2\2\60\65\3\2"+
		"\2\2\61/\3\2\2\2\62\63\5\4\3\2\63\64\7\22\2\2\64\66\3\2\2\2\65\62\3\2"+
		"\2\2\65\66\3\2\2\2\66\3\3\2\2\2\67:\5$\23\289\7\22\2\29;\5\4\3\2:8\3\2"+
		"\2\2:;\3\2\2\2;=\3\2\2\2<>\7\22\2\2=<\3\2\2\2=>\3\2\2\2>Q\3\2\2\2?B\5"+
		"\16\b\2@A\7\22\2\2AC\5\4\3\2B@\3\2\2\2BC\3\2\2\2CE\3\2\2\2DF\7\22\2\2"+
		"ED\3\2\2\2EF\3\2\2\2FQ\3\2\2\2GJ\5*\26\2HI\7\22\2\2IK\5\4\3\2JH\3\2\2"+
		"\2JK\3\2\2\2KM\3\2\2\2LN\7\22\2\2ML\3\2\2\2MN\3\2\2\2NQ\3\2\2\2OQ\5\b"+
		"\5\2P\67\3\2\2\2P?\3\2\2\2PG\3\2\2\2PO\3\2\2\2Q\5\3\2\2\2RU\5\n\6\2SU"+
		"\5\f\7\2TR\3\2\2\2TS\3\2\2\2U\7\3\2\2\2VW\7\36\2\2WX\5\24\13\2XY\7\22"+
		"\2\2YZ\5\4\3\2Z\t\3\2\2\2[\\\7\16\2\2\\]\7\32\2\2]^\7\31\2\2^c\7\22\2"+
		"\2_`\7\3\2\2`a\7\32\2\2ac\7\31\2\2b[\3\2\2\2b_\3\2\2\2c\13\3\2\2\2de\7"+
		"\21\2\2ef\7\31\2\2fj\7\22\2\2gh\7\20\2\2hj\7\31\2\2id\3\2\2\2ig\3\2\2"+
		"\2j\r\3\2\2\2kl\5\30\r\2lm\5\22\n\2ms\3\2\2\2np\5 \21\2oq\5\22\n\2po\3"+
		"\2\2\2pq\3\2\2\2qs\3\2\2\2rk\3\2\2\2rn\3\2\2\2s\17\3\2\2\2tu\5\26\f\2"+
		"uv\5\24\13\2v\21\3\2\2\2w|\5\20\t\2xy\7\7\2\2y{\5\20\t\2zx\3\2\2\2{~\3"+
		"\2\2\2|z\3\2\2\2|}\3\2\2\2}\23\3\2\2\2~|\3\2\2\2\177\u0084\5\32\16\2\u0080"+
		"\u0081\7\17\2\2\u0081\u0083\5\32\16\2\u0082\u0080\3\2\2\2\u0083\u0086"+
		"\3\2\2\2\u0084\u0082\3\2\2\2\u0084\u0085\3\2\2\2\u0085\25\3\2\2\2\u0086"+
		"\u0084\3\2\2\2\u0087\u008d\5&\24\2\u0088\u008d\7\13\2\2\u0089\u008d\7"+
		"\n\2\2\u008a\u008d\7\35\2\2\u008b\u008d\7\37\2\2\u008c\u0087\3\2\2\2\u008c"+
		"\u0088\3\2\2\2\u008c\u0089\3\2\2\2\u008c\u008a\3\2\2\2\u008c\u008b\3\2"+
		"\2\2\u008d\27\3\2\2\2\u008e\u0096\5$\23\2\u008f\u0096\5&\24\2\u0090\u0096"+
		"\5(\25\2\u0091\u0096\5\"\22\2\u0092\u0096\5*\26\2\u0093\u0096\5\34\17"+
		"\2\u0094\u0096\5\36\20\2\u0095\u008e\3\2\2\2\u0095\u008f\3\2\2\2\u0095"+
		"\u0090\3\2\2\2\u0095\u0091\3\2\2\2\u0095\u0092\3\2\2\2\u0095\u0093\3\2"+
		"\2\2\u0095\u0094\3\2\2\2\u0096\31\3\2\2\2\u0097\u009f\5&\24\2\u0098\u009f"+
		"\5(\25\2\u0099\u009f\5\"\22\2\u009a\u009f\5*\26\2\u009b\u009f\5 \21\2"+
		"\u009c\u009f\5\36\20\2\u009d\u009f\5\34\17\2\u009e\u0097\3\2\2\2\u009e"+
		"\u0098\3\2\2\2\u009e\u0099\3\2\2\2\u009e\u009a\3\2\2\2\u009e\u009b\3\2"+
		"\2\2\u009e\u009c\3\2\2\2\u009e\u009d\3\2\2\2\u009f\33\3\2\2\2\u00a0\u00a2"+
		"\7\6\2\2\u00a1\u00a3\5\4\3\2\u00a2\u00a1\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+
		"\u00a4\3\2\2\2\u00a4\u00a5\7\t\2\2\u00a5\35\3\2\2\2\u00a6\u00aa\7\25\2"+
		"\2\u00a7\u00ab\7\36\2\2\u00a8\u00a9\7\5\2\2\u00a9\u00ab\5&\24\2\u00aa"+
		"\u00a7\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00af\3\2"+
		"\2\2\u00ac\u00af\7\23\2\2\u00ad\u00af\7\24\2\2\u00ae\u00a6\3\2\2\2\u00ae"+
		"\u00ac\3\2\2\2\u00ae\u00ad\3\2\2\2\u00af\37\3\2\2\2\u00b0\u00b1\7\4\2"+
		"\2\u00b1\u00b2\5\22\n\2\u00b2\u00b3\7\b\2\2\u00b3!\3\2\2\2\u00b4\u00b8"+
		"\7\f\2\2\u00b5\u00b7\5\32\16\2\u00b6\u00b5\3\2\2\2\u00b7\u00ba\3\2\2\2"+
		"\u00b8\u00b6\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00bb\3\2\2\2\u00ba\u00b8"+
		"\3\2\2\2\u00bb\u00bc\7\r\2\2\u00bc#\3\2\2\2\u00bd\u00be\7\24\2\2\u00be"+
		"%\3\2\2\2\u00bf\u00c0\t\2\2\2\u00c0\'\3\2\2\2\u00c1\u00c2\7,\2\2\u00c2"+
		")\3\2\2\2\u00c3\u00c4\t\3\2\2\u00c4+\3\2\2\2\31/\65:=BEJMPTbipr|\u0084"+
		"\u008c\u0095\u009e\u00a2\u00aa\u00ae\u00b8";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}


text:
<readable><title>3103231330_db98b14501</title><content>
A man in a blue jacket and gloves is standing in the street among other people .
A man in a brightly-colored ski jacket stands with others on a European street .
A man in a colorful jacket walks down the street surrounded by women in winter clothing .
The man in a blue jacket is standing in a crowd .
The man in the blue jacket is walking in a crowd of people past an English pub .
</content></readable>


text:
<?php
namespace FormKit\Widget;
use FormKit\Element;
use DOMText;
use BadMethodCallException;

class Label extends Element
{
    public $class = array('formkit-widget','formkit-label','formkit-widget-label');

    public function __construct($text = null)
    {
        if ( $text ) {
            if ( ! is_string($text) ) {
                throw new Exception("The argument is not a string.");
            }
            $this->addChild( new DOMText($text) );
        }
        parent::__construct('label');
    }

    /**
     * Here is a hack for supportting for $label->for( $elementId );
     *
     * Due to the PHP yacc parser issue, we can't define a method named "for".
     */
    public function __call($m,$a)
    {
        if($m === "for") {
            $this->setAttributeValue($m,$a[0]);
        }
        return parent::__call($m,$a);
    }
}


text:
package com.github.egmerittech.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.event.ApplicationEventMulticaster;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.core.env.Environment;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.mail.MailSender;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

import com.github.egmerittech.repository.EmailTokenRepository;
import com.github.egmerittech.web.event.SignupEvent;
import com.github.egmerittech.web.event.SignupEventListener;

/**
 * @author Greg Baker
 */
@EnableWebSecurity
@EntityScan({ "com.github.egmerittech.model" })
@Import({ com.github.egmerittech.repository.Module.class })
public class ApplicationComponents {

	@Autowired
	private Environment environment;

	@Autowired // this must be autowired to avoid circular dependencies
	private EmailTokenRepository emailTokenRepository;

	@Bean
	public PasswordEncoder passwordEncoder() {
		return new BCryptPasswordEncoder();
	}

	@Bean
	public ApplicationEventMulticaster applicationEventMulticaster() {
		final SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
		eventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
		return eventMulticaster;
	}

	@Bean
	@ConditionalOnProperty("mymerit.sendverifcationemail")
	public ApplicationListener<SignupEvent> signupEventListener(MailSender mailSender) {
		final SignupEventListener eventListener = new SignupEventListener(mailSender, emailTokenRepository);
		eventListener.setExpiryTimeDays(environment.getProperty("mymerit.emailtoken.expirytimedays", Integer.class));
		return eventListener;
	}

}


text:
#import "ROBlockAction.h"

@implementation ROBlockAction

- (instancetype)initWithBlock:(ROActionBlock)actionBlock {

    self = [super init];
    if (self) {

        _actionBlock = actionBlock;
    }
    return self;
}

+ (instancetype)actionWithBlock:(ROActionBlock)actionBlock {

    return [[self alloc] initWithBlock:actionBlock];
}

- (void)doAction {

    _actionBlock();
}

- (BOOL)canDoAction {

    return _actionBlock ? YES : NO;
}

- (UIImage *)actionIcon {

    return nil;
}

@end


text:
<?php

class user extends databaseModel
{
    public $id;
    public $username;
    public $password;
    public $email;
    public $gender;
    public $status;
    public $activation;
    public $privilege;
    public $lastlogin;
    public $table_name = 'users';
    public $fields = [
            'username',
            'password',
            'email',
            'gender',
            'status',
            'activation',
            'privilege',
            'lastlogin',
    ];

    public function __construct($username = false, $password = false, $email = false, $gender = false, $status = false, $privilege = false)
    {
        if ($username != false) {
            $this->username = $username;
        }
        if ($password != false) {
            $this->password = $password;
        }
        if ($email != false) {
            $this->email = $email;
        }
        if ($gender != false) {
            $this->gender = $gender;
        }
        if ($status != false) {
            $this->status = $status;
        }
        if ($privilege != false) {
            $this->privilege = $privilege;
        }

        // $this->lastlogin=date('y-m-d h:i:s');
    }

    public function user_exist()
    {
        $sql = 'SELECT * FROM users WHERE username=\''.$this->username.'\'';
        $check = self::read($sql, PDO::FETCH_CLASS, __CLASS__);
        // var_dump($check);
        return (bool) $check;
    }

    public function email_exist()
    {
        $sql = 'SELECT * FROM users WHERE email=\''.$this->email.'\'';
        $check = self::read($sql, PDO::FETCH_CLASS, __CLASS__);
        // var_dump($check);
        return (bool) $check;
    }

    public static function auth($username, $password)
    {
        $password = md5($username.$password.SAULT);
        $sql = 'SELECT * FROM users WHERE username=\''.$username.'\' AND password=\''.$password.'\' AND status=1';
        $check = self::read($sql, PDO::FETCH_CLASS, __CLASS__);
        if ($check) {
            $_SESSION['logedin'] = true;
            $_SESSION['user'] = $check;
            $check->lastlogin = date('Y-m-d H-i-s');
            if ($check->save()) {
                header('location:'.HOST_NAME);
            }
        } else {
            return false;
        }
    }

    public static function admin_auth($username, $password)
    {
        $password = md5($username.$password.SAULT);
        $sql = 'SELECT * FROM users WHERE username=\''.$username.'\' AND password=\''.$password.'\' AND status=1 AND privilege=1 ';
        $check = self::read($sql, PDO::FETCH_CLASS, __CLASS__);
        if ($check) {
            $_SESSION['logedin'] = true;
            $_SESSION['user'] = $check;
            $check->lastlogin = date('Y-m-d H-i-s');
            if ($check->save()) {
                header('location:'.HOST_NAME.'cpanel');
            }
        } else {
            return false;
        }
    }

    public static function logedin()
    {
        return ($_SESSION['logedin']) ? true : false;
    }

    public function logout()
    {
        unset($_SESSION['logedin']);
        unset($_SESSION['user']);
        header('location:'.HOST_NAME);
    }

    public static function current_user()
    {
        return $_SESSION['user'];
    }

    public function is_Admin()
    {
        return ($this->privilege == 1) ? true : false;
    }

    public static function control()
    {
        $view = $_GET['view'];
        $edit_url = 'cpanel?view='.$view.'&action=edit&item=';
        // $add_url='cpanel?view='.$view.'&action=add';
        $delete_url = 'cpanel?view='.$view.'&action=delete&item=';
        $confirm = 'onclick="if(!confirm(\'Do you want to delete this user\'))return false;"';
        $allusers = self::read('SELECT * FROM users WHERE id !='.self::current_user()->id, PDO::FETCH_CLASS, __CLASS__);
        $table = '

			 Users Table '. //  Add

        '

					 #
					 User
						Name
					 Control

';
        // var_dump($allusers);
        if ($allusers != false && $allusers !== null) {
            if (is_object($allusers)) {
                $table .= '

					1
					'.$allusers->username.'

					id.'" class="btn btn-primary btn-xs">
					 id.'" '.$confirm.' class="btn btn-danger btn-xs">

';
            } else {
                $i = 1;
                foreach ($allusers as $users) {
                    $table .= '

					'.$i++.'
					'.$users->username.'

					id.'" class="btn btn-primary btn-xs">
					 id.'"  '.$confirm.' class="btn btn-danger btn-xs">

';
                }
            }
        } else {
            $table .= '
No users found..
';
        }
        $table .= '

';

        return $table;
    }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE learningContent
  PUBLIC "-//OASIS//DTD DITA Learning Content//EN" "learningContent.dtd">
<learningContent id="learningOutcomes">
   <title>Learning Outcomes</title>
   <learningContentbody>
      <lcObjectives>
         <lcObjectivesStem>By the end of this unit you should be able to:</lcObjectivesStem>
         <lcObjectivesGroup>
            <lcObjective>round a given whole number to the nearest 10, 100, 1000 and so
        on;</lcObjective>
            <lcObjective>round a decimal number to a given number of decimal places or significant
        figures;</lcObjective>
            <lcObjective>use rounded numbers to find rough estimates for
        calculations;</lcObjective>
            <lcObjective>use the course calculator for decimal calculations involving +, −, × and ÷,
        giving your answer to a specified accuracy (e.g. decimal places or significant figures) and
        checking your answer by finding a rough estimate;</lcObjective>
            <lcObjective>check your answers to calculations by ensuring that the correct calculation
        has been done, in the correct order;</lcObjective>
            <lcObjective>check your answers by checking that the units are
        consistent;</lcObjective>
            <lcObjective>check your answers by checking the result against a rough
        estimate;</lcObjective>
            <lcObjective>check your answers by checking that the answer makes sense in the context of
        the problem.</lcObjective>
         </lcObjectivesGroup>
      </lcObjectives>
   </learningContentbody>
</learningContent>


text:
external help file: Microsoft.Azure.Commands.Resources.dll-Help.xml
ms.assetid: BF254F2F-F658-45CC-8AC8-53FF96CFCAAD
online version:
schema: 2.0.0
---

# Get-AzureRmADUser

## SYNOPSIS
Filters active directory users.

## SYNTAX

### EmptyParameterSet (Default)
```
Get-AzureRmADUser [-UserPrincipalName <String>] [-InformationAction <ActionPreference>]
 [-InformationVariable <String>]
```

### SearchStringParameterSet
```
Get-AzureRmADUser -SearchString <String> [-InformationAction <ActionPreference>]
 [-InformationVariable <String>]
```

### ObjectIdParameterSet
```
Get-AzureRmADUser -ObjectId <Guid> [-InformationAction <ActionPreference>] [-InformationVariable <String>]
```

### UPNParameterSet
```
Get-AzureRmADUser -UserPrincipalName <String> [-InformationAction <ActionPreference>]
 [-InformationVariable <String>]
```

### MailParameterSet
```
Get-AzureRmADUser -Mail <String> [-InformationAction <ActionPreference>] [-InformationVariable <String>]
```

## DESCRIPTION
Filters active directory users.

## EXAMPLES

### --------------------------  Filters users using UPN  --------------------------
@{paragraph=PS C:\\\>}

```
PS C:\> Get-AzureRmADUser -UPN foo@domain.com
```

Gets user with foo@domain.com

### --------------------------  Filters users using Search String  --------------------------
@{paragraph=PS C:\\\>}

```
PS C:\> Get-AzureRmADUser -SearchString Joe
```

Filters all ad users that has Joe in the display name.

### --------------------------  List AD users  --------------------------
@{paragraph=PS C:\\\>}

```
PS C:\> Get-AzureRmADUser
```

Gets all AD users

## PARAMETERS

### -UserPrincipalName
UPN of the user.

```yaml
Type: String
Parameter Sets: EmptyParameterSet
Aliases: UPN

Required: False
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

```yaml
Type: String
Parameter Sets: UPNParameterSet
Aliases: UPN

Required: True
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -InformationAction
Specifies how this cmdlet responds to an information event.

The acceptable values for this parameter are:

- Continue
- Ignore
- Inquire
- SilentlyContinue
- Stop
- Suspend

```yaml
Type: ActionPreference
Parameter Sets: (All)
Aliases: infa

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -InformationVariable
Specifies an information variable.

```yaml
Type: String
Parameter Sets: (All)
Aliases: iv

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -SearchString
The user display name

```yaml
Type: String
Parameter Sets: SearchStringParameterSet
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -ObjectId
Object id of the user.

```yaml
Type: Guid
Parameter Sets: ObjectIdParameterSet
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -Mail

```yaml
Type: String
Parameter Sets: MailParameterSet
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

## INPUTS

## OUTPUTS

## NOTES

## RELATED LINKS

[New-AzureRmADUser]()

[Set-AzureRmADUser]()

[Remove-AzureRmADUser]()


text:
typedef enum {
    MGImageResizeCrop,	// analogous to UIViewContentModeScaleAspectFill, i.e. "best fit" with no space around.
    MGImageResizeCropStart,
    MGImageResizeCropEnd,
    MGImageResizeScale	// analogous to UIViewContentModeScaleAspectFit, i.e. scale down to fit, leaving space around if necessary.
} MGImageResizingMethod;

// Temporary solution, we need all these small functions somewhere, maybe inside decorators?
@interface MAImageHelper : NSObject

// offscreen drawing
+ (UIImage *)offscreenDrawnImage:(UIImage *)lazyLoadedImage;

// resize
+ (UIImage *)imageToFitSize:(CGSize)size method:(MGImageResizingMethod)resizeMethod image:(UIImage *)image;
+ (UIImage *)imageToFitSize:(CGSize)fitSize method:(MGImageResizingMethod)resizeMethod image:(UIImage *)image usePixels:(BOOL)usePixels;

+ (UIImage *)imageCroppedToFitSize:(CGSize)size image:(UIImage *)image; // uses MGImageResizeCrop
+ (UIImage *)imageScaledToFitSize:(CGSize)size image:(UIImage *)image; // uses MGImageResizeScale

@end


text:
'use strict'

const _ = require('lodash');
const mongo = require('./mongo');
const fetcher = require('./fetcher');
const error = require('./error');

var bcv_parser = require("bible-passage-reference-parser/js/en_bcv_parser").bcv_parser;
var bcv = new bcv_parser;

function reformatResults(items, hasMultipleTranslations) {
  let result = {
    verses: items
  };

  if (!hasMultipleTranslations) {
    let text = [];
    _(items).forEach(function(item) {
      text.push(item.text);
    });

    result.text = text.join(' ');
  }

  return result;
}

function displayResults(res, mongoQuery, hasMultipleTranslations) {
  if (mongoQuery.length > 0) {
    mongo.open(function(err, collection) {
      collection.find({ $or: mongoQuery }, { _id: 0 })
        .sort({chapter: 1, verse: 1})
        .toArray(function(err, items) {
          res.charSet('utf-8');
          if(items.length > 0) {
            res.send(reformatResults(items, hasMultipleTranslations));
          }
          else {
            res.send(error.onError('Bible passage is not found.'));
          }
        });
    });
  }
  else {
    res.send(error.onError('Bible passage is not found.'));
  }
}

exports.parsePassage = function(req, res) {
  let entities = bcv.parse(req.params.passage).entities;
  if (entities.length < 1) {
    res.send(error.onError('Passage not found.'));
  }

  _(entities).each(function(entity) {
    // passage contains whole book
    if (entity.type === 'b') {
      res.send(error.onError('Please specify passage chapter.'));
    }
    // whole chapter or verse
    else if (entity.type === 'bc' || entity.type === 'bcv') {
      // bcv has only one passage
      const translations = entity.passages[0].translations ? entity.passages[0].translations : [];
      fetcher.fetchBcv(entity.passages[0], entity.type, function(err, result) {
        let hasMultipleTranslations = false;
        if (entity.type === 'bcv' && translations.length > 1) {
          hasMultipleTranslations = true;
        }
        displayResults(res, result, hasMultipleTranslations);
      });
    } // range of verses
    else if (entity.type === 'range') {
      // range has only one passage
      fetcher.fetchRange(entity.passages[0], function(err, result) {
        displayResults(res, result, false);
      });
    } // sequence of passages
    else if(entity.type === 'sequence') {
      _(entity.passages).each(function(passage) {
        // passage sequence includes bcv
        if (passage.type === 'bcv' || passage.type === 'integer') {
          fetcher.fetchBcv(passage, 'bcv', function(err, result) {
            displayResults(res, result, false);
          });
        } // passage sequence includes range
        else if(passage.type === 'range') {
          fetcher.fetchRange(passage, function(err, result) {
            displayResults(res, result, false);
          });
        }
      });
    }
  });
};


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using UnityEngine;

namespace Air2000
{
    public class CityScene : ICityContext
    {
        public enum EventType
        {
            ET_CameraLookAtMenu,
            ET_CameraLookAtRoleSelect,
        }
        public static CityScene Instance { get; set; }
        public CityScene() : base()
        {
            Instance = this;
        }
        public override void Start()
        {
            base.Start();
            ResProvider.LoadSceneAsync("City");
            ContextProvider.StartActivity<MainActivity>();
        }
        public override bool InSceneReady()
        {
            return base.InSceneReady();
        }
    }
}


text:
"""Convolutional operations."""
from choose_matrix_library import *
import math

def ConvolveUp(inputs, edge, target):
  w = edge.params['weight']
  conv = edge.conv_params
  size = conv.size
  stride = conv.stride
  padding = conv.padding
  num_filters = conv.num_filters
  num_colors = conv.num_colors

  f, numdims = w.shape
  assert f == num_filters, 'f is %d but num_filters is %d' % (f, num_filters)
  if edge.conv:
    assert numdims == size**2 * num_colors

  input_t = edge.input_t
  inputs.transpose(input_t)
  # Convolve Up.
  if conv.max_pool:
    output_t = edge.unpooled_layer
  elif conv.rnorm:
    output_t = edge.unrnormalized_layer
  else:
    output_t = edge.output_t

  numimages, numdims = input_t.shape
  numimages2, numdims2 = output_t.shape
  assert numimages == numimages2, '%d %d.' % (numimages, numimages2)
  assert numdims % num_colors == 0
  x = int(math.sqrt(numdims / num_colors))
  assert x**2 == numdims/num_colors
  n_locs = (x + 2 * padding - size) / stride + 1
  if edge.conv:
    cc.convUp(input_t, w, output_t, n_locs, padding, stride, num_colors)
  else:
    cc.localUp(input_t, w, output_t, n_locs, padding, stride, num_colors)

  # Do maxpooling
  if conv.max_pool:
    input_t = output_t
    if conv.rnorm:
      output_t = edge.unrnormalized_layer
    else:
      output_t = edge.output_t
    n_locs = (n_locs - conv.pool_size) / conv.pool_stride + 1
    if conv.prob:
      rnd = edge.rnd
      rnd.fill_with_rand()
      cm.log(rnd)
      rnd.mult(-1)
      #cm.log(rnd)
      #rnd.mult(-1)
      cc.ProbMaxPool(input_t, rnd, output_t, num_filters, conv.pool_size, 0, conv.pool_stride, n_locs)
    else:
      cc.MaxPool(input_t, output_t, num_filters, conv.pool_size, 0, conv.pool_stride, n_locs)
  if conv.rnorm:
    input_t = output_t
    output_t = edge.output_t
    denoms = edge.denoms
    sizeX = conv.norm_size
    add_scale = conv.add_scale
    pow_scale = conv.pow_scale
    cc.ResponseNorm(input_t, denoms, output_t, num_filters, sizeX, add_scale, pow_scale)
  output_t.transpose(target)

def AccumulateConvDeriv(layer, edge, deriv):
  """Accumulate the derivative w.r.t the outputs of this layer.

  Each layer needs to compute derivatives w.r.t its outputs. These outputs may
  have been connected to lots of other nodes through outgoing edges.
  This method adds up the derivatives contributed by each outgoing edge.
  It gets derivatives w.r.t the inputs at the other end of an outgoing edge.
  Args:
    edge: The edge which is sending the derivative.
    deriv: The derivative w.r.t the inputs at the other end of this edge.
  """

  if layer.dirty:  # If some derivatives have already been received.
    raise Exception('Not implemented.')
  layer.dirty = True
  w = edge.params['weight']
  conv = edge.conv_params
  size = conv.size
  stride = conv.stride
  padding = conv.padding
  num_filters = conv.num_filters
  num_colors = conv.num_colors

  input_t = edge.input_t
  numImages, numdims = input_t.shape

  assert numdims % num_colors == 0
  x = int(math.sqrt(numdims / num_colors))
  assert x**2 == numdims/num_colors

  n_locs = (x + 2 * padding - size) / stride + 1

  # Incoming gradient.
  deriv.transpose(edge.output_t2)
  input_grads = edge.output_t2

  # Output activation (after conv + pool? + norm?)
  output_acts = edge.output_t

  if conv.rnorm:

    # ResponseNormUndo overwrites input_acts, so make a copy.
    input_acts = edge.rnorm_temp1
    input_acts.assign(edge.unrnormalized_layer)

    output_grads = edge.rnorm_temp2
    denoms = edge.denoms

    sizeX = conv.norm_size
    pow_scale = conv.pow_scale
    add_scale = conv.add_scale
    cc.ResponseNormUndo(input_grads, denoms, output_acts, input_acts,
                        output_grads, num_filters, sizeX, add_scale,
                        pow_scale)
    input_grads = output_grads
    output_acts = edge.unrnormalized_layer

  if conv.max_pool:
    input_acts = edge.unpooled_layer
    output_grads = edge.unpooled_layer
    # It's OK to overwrite input_acts because we don't need it later.

    n_pool_locs = (n_locs - conv.pool_size) / conv.pool_stride + 1
    sizeX = conv.pool_size
    strideX = conv.pool_stride
    cc.MaxPoolUndo(output_grads, input_acts, input_grads, output_acts, sizeX,
                   0, strideX, n_pool_locs)
    input_grads = output_grads
    output_acts = input_acts
  if layer.is_input:
    return

  output_grads = edge.input_t2
  if edge.conv:
    cc.convDown(input_grads, w, output_grads, n_locs, padding, stride, size, x, num_colors)
  else:
    cc.localDown(input_grads, w, output_grads, n_locs, padding, stride, size, x, num_colors)
  output_grads.transpose(layer.deriv)

def ConvOuter(edge, grad):
  """Get the gradient for the weights in this edge.
  Args:
    grad: (output) the gradient for the weights in this edge.
  """
  w = edge.params['weight']
  conv = edge.conv_params
  size = conv.size
  stride = conv.stride
  padding = conv.padding
  num_filters = conv.num_filters
  num_colors = conv.num_colors

  f, numdims = w.shape
  assert f == num_filters, 'f is %d but num_filters is %d' % (f, num_filters)
  if edge.conv:
    assert numdims == size**2 * num_colors
  input_t = edge.input_t
  if conv.max_pool:
    output_t = edge.unpooled_layer
  elif conv.rnorm:
    output_t = edge.rnorm_temp2
  else:
    output_t = edge.output_t2
  numdims, numimages = edge.node1.state.shape

  assert numdims % num_colors == 0
  x = int(math.sqrt(numdims / num_colors))

  assert x**2 == numdims/num_colors

  n_locs = (x + 2 * padding - size) / stride + 1

  if edge.conv:
    cc.convOutp(input_t, output_t, grad, n_locs, padding, size, stride, num_colors)
  else:
    cc.localOutp(input_t, output_t, grad, n_locs, padding, size, stride, num_colors)

def AddConvolveUp(inputs, edge, target):
  raise Exception('Not implemented.')