text:
<?php

/**
 * Default log out handler. You can specify a `redirect` value
 * to send them to after logging out.
 */

// Check for a custom handler override
$res = $this->override ('user/logout');
if ($res) { echo $res; return; }

if (! isset ($_GET['redirect'])) {
	$_GET['redirect'] = Appconf::user ('User', 'logout_redirect');
}

if (! Validator::validate ($_GET['redirect'], 'header')) {
	$_GET['redirect'] = '/';
}

$_GET['redirect'] = filter_var ($_GET['redirect'], FILTER_SANITIZE_URL);

if (! Validator::validate ($_GET['redirect'], 'localpath')) {
	$_GET['redirect'] = '/';
}

$redir = parse_url ($_GET['redirect']);
if ($redir === false || $_GET['redirect'] !== $redir['path'] && $_GET['redirect'] !== $redir['path'] . '?' . $redir['query']) {
	$_GET['redirect'] = '/';
}

Lock::clear ();
echo User::logout ($_GET['redirect']);


text:
int arithmetic_roulette_select(unsigned int range) {
	srand(time(NULL));

	unsigned int seed = range * ( range + 1 ) / 2;

	int random_num = rand() % seed;

	while(random_num < 0)
		random_num -= range--;

	return range;
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace tunecino\builder\generators\restModule;

use Yii;
use yii\db\ActiveQuery;
use yii\db\ActiveRecord;
use yii\gii\generators\module\Generator as GiiGenerator;

class Generator extends \tunecino\builder\Generator
{

    public function getCoreAttributes()
    {
        return [
            'generateAsModule' => false,
            'moduleNamespace' => null,
        ];
    }

    public function attributeLabels()
    {
        return array_merge(parent::attributeLabels(), [
            'generateAsModule' => 'Generate it as Module',
            'moduleNamespace' => 'Module Namespace',
        ]);
    }

    public function rules()
    {
        return array_merge(parent::rules(), [
            ['moduleNamespace', 'filter', 'filter' => 'trim'],
            ['generateAsModule', 'boolean'],
            ['moduleNamespace', 'filter', 'filter' => function($value) { return trim($value, '\\'); }],
            ['moduleNamespace', 'required', 'when' => function($model) { return $model->generateAsModule; }],
            ['moduleNamespace', 'match', 'pattern' => '/^[\w\\\\]+$/', 'message' => 'Only word characters and backslashes are allowed.'],
            ['moduleNamespace', 'validateNamespace'],
            ['template', 'required', 'when' => function($model) { return $model->generateAsModule; }, 'message' => 'A code template must be selected.'],
            ['messageCategory', 'validateMessageCategory', 'when' => function($model) { return $model->generateAsModule; }],
            [['appconfig','template'], 'filter', 'filter' => 'trim'],
            ['appconfig', 'validateFilePath', 'when' => function($model) { return $model->generateAsModule; }],
        ]);
    }

    public function attributeHints()
    {
        return array_merge(parent::attributeHints(), (new GiiGenerator)->hints(), [
            'generateAsModule' => 'This indicates whether this schema should be generated as a seperate module.',
            'moduleNamespace' => 'This is the namespace of the Module class to be generated, e.g., app\modules. You\'ll also need to alter the namecpaces of the other settings like models and controllers whenever it should be generated into this Module.',
        ]);
    }

    public function getModuleID()
    {
        return ($this->schema && $this->schema->name) ? \yii\helpers\Inflector::variablize($this->schema->name) : null;
    }

    public function getConsoleCommands()
    {
        $cmd = 'yii gii/rest-module';
        if ($this->moduleID) $cmd .= ' --moduleID="'. $this->moduleID .'"';
        if ($this->moduleNamespace) $cmd .= ' --moduleClass="'. $this->moduleNamespace . '\\' . $this->moduleID . '\\' . 'Module"';
        $cmd .= ' --interactive=0 --overwrite=1';
        return $this->moduleNamespace ? [$cmd] : [];
    }

    public function afterSave($insert, $changedAttributes)
    {
        if (($insert && $this->generateAsModule) || isset($changedAttributes['generateAsModule'])) {
            $schema = $this->schema;
            $schema->isModule = $this->generateAsModule;
            $schema->save();
        }
        parent::afterSave($insert, $changedAttributes);
    }

}


text:
namespace Cooking
{
    using System;
    using Culinary;
    using Culinary.Ingredients.Vegetables;

    public class CookVegetables
    {
        public static void Main()
        {
            Chef chef = new Chef();
            Potato potato = new Potato();
            if (potato == null)
            {
                throw new ArgumentNullException("Potato should be created.");
            }
            else if (potato.IsPeeled && potato.IsRotten)
            {
                    chef.Cook(potato);
            }
        }
    }
}


text:
namespace DemoDataService.Areas.HelpPage.ModelDescriptions
{
    public class SimpleTypeModelDescription : ModelDescription
    {
    }
}


text:
require "optparse"
require "passphrase/wordlist_database"

module Passphrase
  # The CLI class encapsulates a simple command line interface to the
  # {Passphrase} library. The class method {parse} merges any given command
  # line arguments with a hash of default options. The resulting hash is then
  # used to instantiate a Passphrase object and generate one passphrase, which
  # is printed on standard output.
  # @example
  #   require "passphrase"
  #   Passphrase::CLI.parse(ARGV)
  class CLI
    # @param args [Array<String>] array of command line elements, typically
    #   given by ARGV (may be empty)
    # @return [void]
    def self.parse(args)
      # Gotcha:
      # The contents of an instance variable can be changed outside the class
      # through a reader attribute. For example,
      #   class A
      #     attr_reader :x
      #     def initialize
      #       @x = { a: 1, b: 2 }
      #     end
      #   end
      #   a = A.new
      #   p a.x        #=> {:a=>1, :b=>2}
      #   x = a.x
      #   x[:b] = 99
      #   p a.x        #=> {:a=>1, :b=>99}
      # Therefore, need to clone the default hash otherwise parsing could
      # alter the hash's contents. Although this causes no harm in the
      # command-line tool, it causes havoc in the test suite.
      options = Default.options.clone

      default_number_of_words = Default.options[:number_of_words]
      default_passwordize = Default.options[:passwordize] ? "--passwordize" : "--no-passwordize"
      default_random_org = Default.options[:use_random_org] ? "--random-org" : "--no-random-org"
      default_number_range = Default.number_range

      parser = OptionParser.new(nil, 28, " " * 4) do |opts|
        opts.banner = "Usage: passphrase [options]"
        opts.on(:OPTIONAL, "-l", "--languages=LANG1,...", Array,
          "Specify languages to use, none for a listing",
          "(default: --languages=all)") do |l|
            options[:languages] = (l || [])
        end
        opts.on(:REQUIRED, "-n NUM", "--num-words=NUM", Integer,
          "Number of words in passphrase #{default_number_range}",
          "(default: --num-words=#{default_number_of_words})") do |n|
            options[:number_of_words] = n
        end
        opts.on(:NONE, "-p", "--[no-]passwordize",
          "Add one cap, one num, and one special char",
          "(default: #{default_passwordize})") do |p|
            options[:passwordize] = p
        end
        opts.on(:NONE, "-r", "--[no-]random-org",
          "Use RANDOM.ORG to generate random numbers",
          "(default: #{default_random_org})") do |r|
            options[:use_random_org] = r
        end
        opts.on_tail("-h", "--help", "Show this message") do
          puts opts
          exit(0)
        end
        opts.on_tail("-v", "--version", "Show version") do
          puts VERSION
          exit(0)
        end
      end

      begin
        parser.parse!(args)
        display_languages(options)
        validate_number_of_words(options)
        passphrase = Passphrase.new(options).passphrase
        print_out(passphrase, options)
      rescue OptionParser::InvalidOption => e
        handle_error(e)
      rescue OptionParser::MissingArgument => e
        handle_error(e)
      # Gracefully handle exit(0) from --help, --version, and --language options
      rescue SystemExit => e
        exit(e.status)
      rescue Exception => e
        handle_error(e)
      end
    end

    def self.display_languages(options)
      if options[:languages].empty?
        puts WordlistDatabase.connect.from(:languages).all
        exit(0)
      end
    end

    def self.validate_number_of_words(options)
      number_of_words = options[:number_of_words]
      unless Default.number_range.include?(number_of_words)
        raise "Number of words out of range #{Default.number_range}"
      end
    end

    def self.print_out(passphrase, options)
      puts passphrase
      puts passphrase.to_password if options[:passwordize]
    end

    def self.handle_error(error)
      STDERR.puts "ERROR: #{error.message}"
      exit(1)
    end

    class << self
      private :display_languages
      private :validate_number_of_words
      private :print_out
      private :handle_error
    end
  end
end


text:
@interface PodsDummy_Pods_OFRequestManager : NSObject
@end
@implementation PodsDummy_Pods_OFRequestManager
@end


text:
.class final Lo/aN;
.super Ljava/lang/Object;

# interfaces
.implements Lo/ey$if;

# annotations
.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x8
    name = null
.end annotation

# instance fields
.field final synthetic ˊ:Lcom/google/android/gms/common/api/Status;

# direct methods
.method constructor <init>(Lcom/google/android/gms/common/api/Status;)V
    .locals 0

    iput-object p1, p0, Lo/aN;->ˊ:Lcom/google/android/gms/common/api/Status;

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

    return-void
.end method

# virtual methods
.method public ˊ()Lcom/google/android/gms/common/api/Status;
    .locals 1

    iget-object v0, p0, Lo/aN;->ˊ:Lcom/google/android/gms/common/api/Status;

    return-object v0
.end method

.method public ˏ()V
    .locals 0

    return-void
.end method


text:
package org.jitsi.videobridge.rest;

import java.net.*;

import javax.servlet.*;
import javax.servlet.http.*;

import org.eclipse.jetty.proxy.*;

/**
 * Fixes defects of Jetty's {@code ProxyServlet}.
 *
 * @author Lyubomir Marinov
 */
public class ProxyServletImpl
    extends ProxyServlet.Transparent
{
    /**
     * The "proxyTo" {@code ServletConfig} init parameter required by
     * Jetty's transparent {@code ProxyServlet}.
     */
    private String proxyTo;

    /**
     * {@inheritDoc}
     */
    @Override
    public void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);

        // Jetty's transparent ProxyServlet may introduce a / at the end of the
        // request path. Such behavior is incorrect.
        String proxyTo = config.getInitParameter("proxyTo");

        if (proxyTo != null && !proxyTo.endsWith("/"))
            this.proxyTo = proxyTo;
    }

    /**
     * {@inheritDoc}
     *
     * If Jetty's transparent {@code ProxyServlet} introduces a / at the end of
     * the request path, removes it (because such behavior is incorrect).
     */
    @Override
    protected URI rewriteURI(HttpServletRequest request)
    {
        URI rewrittenURI = super.rewriteURI(request);

        if (proxyTo != null)
        {
            String requestPath = request.getRequestURI();

            if (requestPath != null && !requestPath.endsWith("/"))
            {
                String rewrittenPath = rewrittenURI.getPath();
                int len;

                if (rewrittenPath != null
                        && (len = rewrittenPath.length()) > 1
                        && rewrittenPath.endsWith("/"))
                {
                    rewrittenPath = rewrittenPath.substring(0, len - 1);

                    try
                    {
                        rewrittenURI
                            = new URI(
                                    rewrittenURI.getScheme(),
                                    rewrittenURI.getAuthority(),
                                    rewrittenPath,
                                    rewrittenURI.getQuery(),
                                    rewrittenURI.getFragment());
                    }
                    catch (URISyntaxException urise)
                    {
                    }
                }
            }
        }
        return rewrittenURI;
    }
}


text:
<?php

namespace Jimdo\JimFlow\ViewBoardBundle\Model;

interface TicketProviderInterface {

    public function getTicketByCode($code);

    public function setTicketStatusByCodeAndStatus($code, $status, $newBoardColumn);
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Cercospora filicum Henn.

### Remarks
null


text:
package br.com.alvaro.facade.impl;

import javax.ejb.EJB;
import javax.ejb.Local;
import javax.ejb.Stateless;

import br.com.alvaro.dao.PacienteDAO;
import br.com.alvaro.entity.Paciente;
import br.com.alvaro.facade.PacienteFacade;

@Stateless
@Local(PacienteFacade.class)
public class PacienteFacadeImpl implements PacienteFacade {

	@EJB
	private PacienteDAO pacienteDao;

	@Override
	public Paciente find() {

		try {
			return pacienteDao.findOneResultByIdPaciente(new Long(100));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

}


text:
    <md-content flex layout="column">

    </md-content>


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
Animator.Direction
</TITLE>

<META NAME="date" CONTENT="2013-09-06">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../../stylesheet.css" TITLE="Style">

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD

DETAIL: ENUM CONSTANTS | FIELD | METHOD

org.jdesktop.core.animation.timing

Enum Animator.Direction

java.lang.Object
  java.lang.Enum<Animator.Direction>
      org.jdesktop.core.animation.timing.Animator.Direction

All Implemented Interfaces:
java.io.Serializable, java.lang.Comparable<Animator.Direction>

Enclosing class:
Animator

@Immutable
public static enum Animator.Direction
extends java.lang.Enum<Animator.Direction>

Direction is used to set the initial direction in which the animation
 starts.

See Also:
Builder#setStartDirection(Animator.Direction)

Enum Constant Summary

BACKWARD

          The cycle proceeds backward.

FORWARD

          The cycle proceeds forward.

Method Summary

abstract  Animator.Direction
getOppositeDirection()

static Animator.Direction
valueOf(java.lang.String name)

          Returns the enum constant of this type with the specified name.

static Animator.Direction[]
values()

          Returns an array containing the constants of this enum type, in
the order they are declared.

Methods inherited from class java.lang.Enum

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Enum Constant Detail

FORWARD

public static final Animator.Direction FORWARD

The cycle proceeds forward.

BACKWARD

public static final Animator.Direction BACKWARD

The cycle proceeds backward.

Method Detail

values

public static Animator.Direction[] values()

Returns an array containing the constants of this enum type, in
the order they are declared.  This method may be used to iterate
over the constants as follows:

for (Animator.Direction c : Animator.Direction.values())
    System.out.println(c);

Returns:
an array containing the constants of this enum type, in
the order they are declared

valueOf

public static Animator.Direction valueOf(java.lang.String name)

Returns the enum constant of this type with the specified name.
The string must match exactly an identifier used to declare an
enum constant in this type.  (Extraneous whitespace characters are
not permitted.)

Parameters:
name - the name of the enum constant to be returned.

Returns:
the enum constant with the specified name

Throws:

java.lang.IllegalArgumentException - if this enum type has no constant
with the specified name

java.lang.NullPointerException - if the argument is null

getOppositeDirection

public abstract Animator.Direction getOppositeDirection()

      Overview
      Package
    Class
      Tree
      Deprecated
      Index
      Help

 PREV CLASS
 NEXT CLASS

  FRAMES
 NO FRAMES

  All Classes

  SUMMARY: NESTED | ENUM CONSTANTS | FIELD | METHOD

DETAIL: ENUM CONSTANTS | FIELD | METHOD


text:
package erogenousbeef.bigreactors.utils.intermod;

import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.ModAPIManager;

public class ModHelperBase {

	public static boolean useCofh;
	public static boolean useBuildcraftTools;
	public static boolean useBuildcraftTransport;

	public void register() {}

	public static void detectMods() {

		useCofh = Loader.isModLoaded("CoFHCore");
		useBuildcraftTools = ModAPIManager.INSTANCE.hasAPI("BuildCraftAPI|tools");
		useBuildcraftTransport = ModAPIManager.INSTANCE.hasAPI("BuildCraftAPI|transport");

	}

}


text:
use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode};
use ::RegType::*;
use ::instruction_def::*;
use ::Operand::*;
use ::Reg::*;
use ::RegScale::*;

fn cmp_1() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(Direct(CL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 203], OperandSize::Word)
}

fn cmp_2() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexed(BP, DI, One, Some(OperandSize::Byte), None)), operand2: Some(Direct(DL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 19], OperandSize::Word)
}

fn cmp_3() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DL)), operand2: Some(Direct(DL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 210], OperandSize::Dword)
}

fn cmp_4() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledDisplaced(EBX, Two, 536577032, Some(OperandSize::Byte), None)), operand2: Some(Direct(BL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 28, 93, 8, 132, 251, 31], OperandSize::Dword)
}

fn cmp_5() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(Direct(BL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 219], OperandSize::Qword)
}

fn cmp_6() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledDisplaced(RDX, Four, 2121713826, Some(OperandSize::Byte), None)), operand2: Some(Direct(CL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 12, 149, 162, 200, 118, 126], OperandSize::Qword)
}

fn cmp_7() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DL)), operand2: Some(Direct(DL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 210], OperandSize::Qword)
}

fn cmp_8() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(RDI, 2086307932, Some(OperandSize::Byte), None)), operand2: Some(Direct(BL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 159, 92, 136, 90, 124], OperandSize::Qword)
}

fn cmp_9() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BP)), operand2: Some(Direct(SP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 229], OperandSize::Word)
}

fn cmp_10() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(BX, SI, One, 189, Some(OperandSize::Word), None)), operand2: Some(Direct(BP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 168, 189, 0], OperandSize::Word)
}

fn cmp_11() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(SP)), operand2: Some(Direct(DI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 252], OperandSize::Dword)
}

fn cmp_12() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Indirect(ESI, Some(OperandSize::Word), None)), operand2: Some(Direct(SI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 54], OperandSize::Dword)
}

fn cmp_13() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DX)), operand2: Some(Direct(BX)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 218], OperandSize::Qword)
}

fn cmp_14() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(RSI, 1897335029, Some(OperandSize::Word), None)), operand2: Some(Direct(SP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 166, 245, 8, 23, 113], OperandSize::Qword)
}

fn cmp_15() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ESI)), operand2: Some(Direct(ESP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 230], OperandSize::Word)
}

fn cmp_16() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Memory(31959, Some(OperandSize::Dword), None)), operand2: Some(Direct(ESI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 54, 215, 124], OperandSize::Word)
}

fn cmp_17() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ECX)), operand2: Some(Direct(EDX)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 209], OperandSize::Dword)
}

fn cmp_18() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexed(EBX, EBX, Four, Some(OperandSize::Dword), None)), operand2: Some(Direct(ESI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 52, 155], OperandSize::Dword)
}

fn cmp_19() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBP)), operand2: Some(Direct(ESP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 229], OperandSize::Qword)
}

fn cmp_20() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(RCX, RAX, Four, 1031883332, Some(OperandSize::Dword), None)), operand2: Some(Direct(EDX)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 148, 129, 68, 74, 129, 61], OperandSize::Qword)
}

fn cmp_21() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RDI)), operand2: Some(Direct(RBP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 57, 239], OperandSize::Qword)
}

fn cmp_22() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(RDI, RCX, Two, 212642884, Some(OperandSize::Qword), None)), operand2: Some(Direct(RDI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 57, 188, 79, 68, 172, 172, 12], OperandSize::Qword)
}

fn cmp_23() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DL)), operand2: Some(Direct(BL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 218], OperandSize::Word)
}

fn cmp_24() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(IndirectScaledIndexed(BX, SI, One, Some(OperandSize::Byte), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[58, 24], OperandSize::Word)
}

fn cmp_25() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CL)), operand2: Some(Direct(DL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 209], OperandSize::Dword)
}

fn cmp_26() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CL)), operand2: Some(IndirectScaledDisplaced(ESI, Two, 1918228665, Some(OperandSize::Byte), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[58, 12, 117, 185, 216, 85, 114], OperandSize::Dword)
}

fn cmp_27() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DL)), operand2: Some(Direct(CL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 202], OperandSize::Qword)
}

fn cmp_28() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(IndirectScaledDisplaced(RAX, Eight, 1026505262, Some(OperandSize::Byte), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[58, 28, 197, 46, 58, 47, 61], OperandSize::Qword)
}

fn cmp_29() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(Direct(CL)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[56, 203], OperandSize::Qword)
}

fn cmp_30() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CL)), operand2: Some(IndirectScaledIndexed(RDX, RCX, Four, Some(OperandSize::Byte), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[58, 12, 138], OperandSize::Qword)
}

fn cmp_31() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(SP)), operand2: Some(Direct(SI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 244], OperandSize::Word)
}

fn cmp_32() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CX)), operand2: Some(IndirectDisplaced(DI, 250, Some(OperandSize::Word), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[59, 141, 250, 0], OperandSize::Word)
}

fn cmp_33() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BX)), operand2: Some(Direct(DI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 251], OperandSize::Dword)
}

fn cmp_34() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DI)), operand2: Some(Indirect(ESI, Some(OperandSize::Word), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 59, 62], OperandSize::Dword)
}

fn cmp_35() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CX)), operand2: Some(Direct(DX)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 209], OperandSize::Qword)
}

fn cmp_36() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(SI)), operand2: Some(IndirectDisplaced(RDI, 1857992281, Some(OperandSize::Word), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 59, 183, 89, 182, 190, 110], OperandSize::Qword)
}

fn cmp_37() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ECX)), operand2: Some(Direct(ESP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 57, 225], OperandSize::Word)
}

fn cmp_38() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ESI)), operand2: Some(IndirectDisplaced(BX, 25860, Some(OperandSize::Dword), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 59, 183, 4, 101], OperandSize::Word)
}

fn cmp_39() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBX)), operand2: Some(Direct(ESP)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 227], OperandSize::Dword)
}

fn cmp_40() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EDX)), operand2: Some(IndirectDisplaced(ECX, 1719819487, Some(OperandSize::Dword), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[59, 145, 223, 92, 130, 102], OperandSize::Dword)
}

fn cmp_41() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBX)), operand2: Some(Direct(ESI)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[57, 243], OperandSize::Qword)
}

fn cmp_42() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ESP)), operand2: Some(Indirect(RBX, Some(OperandSize::Dword), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[59, 35], OperandSize::Qword)
}

fn cmp_43() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RSI)), operand2: Some(Direct(RDX)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 57, 214], OperandSize::Qword)
}

fn cmp_44() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RSP)), operand2: Some(IndirectScaledIndexedDisplaced(RCX, RSI, Four, 1825367550, Some(OperandSize::Qword), None)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 59, 164, 177, 254, 229, 204, 108], OperandSize::Qword)
}

fn cmp_45() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AL)), operand2: Some(Literal8(22)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[60, 22], OperandSize::Word)
}

fn cmp_46() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AL)), operand2: Some(Literal8(19)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[60, 19], OperandSize::Dword)
}

fn cmp_47() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AL)), operand2: Some(Literal8(81)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[60, 81], OperandSize::Qword)
}

fn cmp_48() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AX)), operand2: Some(Literal16(4641)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[61, 33, 18], OperandSize::Word)
}

fn cmp_49() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AX)), operand2: Some(Literal16(10255)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 61, 15, 40], OperandSize::Dword)
}

fn cmp_50() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(AX)), operand2: Some(Literal16(21985)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 61, 225, 85], OperandSize::Qword)
}

fn cmp_51() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EAX)), operand2: Some(Literal32(1347797765)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 61, 5, 195, 85, 80], OperandSize::Word)
}

fn cmp_52() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EAX)), operand2: Some(Literal32(367480829)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[61, 253, 79, 231, 21], OperandSize::Dword)
}

fn cmp_53() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EAX)), operand2: Some(Literal32(2042855317)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[61, 149, 127, 195, 121], OperandSize::Qword)
}

fn cmp_54() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RAX)), operand2: Some(Literal32(1726395969)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 61, 65, 182, 230, 102], OperandSize::Qword)
}

fn cmp_55() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CL)), operand2: Some(Literal8(7)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 249, 7], OperandSize::Word)
}

fn cmp_56() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Indirect(DI, Some(OperandSize::Byte), None)), operand2: Some(Literal8(93)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 61, 93], OperandSize::Word)
}

fn cmp_57() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(Literal8(97)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 251, 97], OperandSize::Dword)
}

fn cmp_58() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Indirect(EDI, Some(OperandSize::Byte), None)), operand2: Some(Literal8(30)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 63, 30], OperandSize::Dword)
}

fn cmp_59() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BL)), operand2: Some(Literal8(89)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 251, 89], OperandSize::Qword)
}

fn cmp_60() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexed(RDX, RDX, Four, Some(OperandSize::Byte), None)), operand2: Some(Literal8(13)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 60, 146, 13], OperandSize::Qword)
}

fn cmp_61() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DL)), operand2: Some(Literal8(0)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 250, 0], OperandSize::Qword)
}

fn cmp_62() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(RDX, RBX, Two, 417226264, Some(OperandSize::Byte), None)), operand2: Some(Literal8(12)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[128, 188, 90, 24, 94, 222, 24, 12], OperandSize::Qword)
}

fn cmp_63() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(SP)), operand2: Some(Literal16(26880)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 252, 0, 105], OperandSize::Word)
}

fn cmp_64() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(SI, 82, Some(OperandSize::Word), None)), operand2: Some(Literal16(26252)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 124, 82, 140, 102], OperandSize::Word)
}

fn cmp_65() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BP)), operand2: Some(Literal16(32126)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 253, 126, 125], OperandSize::Dword)
}

fn cmp_66() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledDisplaced(EBX, Eight, 599382474, Some(OperandSize::Word), None)), operand2: Some(Literal16(15975)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 60, 221, 202, 217, 185, 35, 103, 62], OperandSize::Dword)
}

fn cmp_67() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(DI)), operand2: Some(Literal16(21144)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 255, 152, 82], OperandSize::Qword)
}

fn cmp_68() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(RAX, RCX, Four, 192019599, Some(OperandSize::Word), None)), operand2: Some(Literal16(28502)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 188, 136, 143, 252, 113, 11, 86, 111], OperandSize::Qword)
}

fn cmp_69() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBX)), operand2: Some(Literal32(671851597)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 251, 77, 164, 11, 40], OperandSize::Word)
}

fn cmp_70() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(SI, 23149, Some(OperandSize::Dword), None)), operand2: Some(Literal32(1894081732)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 129, 188, 109, 90, 196, 100, 229, 112], OperandSize::Word)
}

fn cmp_71() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBP)), operand2: Some(Literal32(571979322)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 253, 58, 182, 23, 34], OperandSize::Dword)
}

fn cmp_72() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexed(ESI, EDX, Eight, Some(OperandSize::Dword), None)), operand2: Some(Literal32(2007038364)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 60, 214, 156, 249, 160, 119], OperandSize::Dword)
}

fn cmp_73() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EBP)), operand2: Some(Literal32(849025419)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 253, 139, 25, 155, 50], OperandSize::Qword)
}

fn cmp_74() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(RDX, RBX, Two, 166564846, Some(OperandSize::Dword), None)), operand2: Some(Literal32(231809818)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[129, 188, 90, 238, 147, 237, 9, 26, 35, 209, 13], OperandSize::Qword)
}

fn cmp_75() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RDI)), operand2: Some(Literal32(1155005174)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 129, 255, 246, 250, 215, 68], OperandSize::Qword)
}

fn cmp_76() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledDisplaced(RDX, Eight, 1533054685, Some(OperandSize::Qword), None)), operand2: Some(Literal32(854433758)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 129, 60, 213, 221, 142, 96, 91, 222, 159, 237, 50], OperandSize::Qword)
}

fn cmp_77() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(SP)), operand2: Some(Literal8(81)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 252, 81], OperandSize::Word)
}

fn cmp_78() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(BX, 9899, Some(OperandSize::Word), None)), operand2: Some(Literal8(10)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 191, 171, 38, 10], OperandSize::Word)
}

fn cmp_79() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(BP)), operand2: Some(Literal8(77)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 253, 77], OperandSize::Dword)
}

fn cmp_80() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(ESI, ESI, Two, 281466997, Some(OperandSize::Word), None)), operand2: Some(Literal8(91)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 188, 118, 117, 216, 198, 16, 91], OperandSize::Dword)
}

fn cmp_81() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(CX)), operand2: Some(Literal8(116)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 249, 116], OperandSize::Qword)
}

fn cmp_82() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Indirect(RBX, Some(OperandSize::Word), None)), operand2: Some(Literal8(39)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 59, 39], OperandSize::Qword)
}

fn cmp_83() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ESP)), operand2: Some(Literal8(44)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 252, 44], OperandSize::Word)
}

fn cmp_84() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectDisplaced(BX, 207, Some(OperandSize::Dword), None)), operand2: Some(Literal8(81)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[102, 131, 191, 207, 0, 81], OperandSize::Word)
}

fn cmp_85() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(ECX)), operand2: Some(Literal8(38)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 249, 38], OperandSize::Dword)
}

fn cmp_86() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledIndexedDisplaced(EAX, EDX, Two, 4599614, Some(OperandSize::Dword), None)), operand2: Some(Literal8(105)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 188, 80, 62, 47, 70, 0, 105], OperandSize::Dword)
}

fn cmp_87() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(EDI)), operand2: Some(Literal8(91)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 255, 91], OperandSize::Qword)
}

fn cmp_88() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Indirect(RCX, Some(OperandSize::Dword), None)), operand2: Some(Literal8(97)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[131, 57, 97], OperandSize::Qword)
}

fn cmp_89() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(Direct(RDX)), operand2: Some(Literal8(56)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 131, 250, 56], OperandSize::Qword)
}

fn cmp_90() {
    run_test(&Instruction { mnemonic: Mnemonic::CMP, operand1: Some(IndirectScaledDisplaced(RCX, Eight, 1634964012, Some(OperandSize::Qword), None)), operand2: Some(Literal8(37)), operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[72, 131, 60, 205, 44, 146, 115, 97, 37], OperandSize::Qword)
}


text:
# gsort2hp

> Simultaneously sort two strided arrays based on the sort order of the first array using heapsort.

## Usage

```javascript
var gsort2hp = require( '@stdlib/blas/ext/base/gsort2hp' );
```

#### gsort2hp( N, order, x, strideX, y, strideY )

Simultaneously sorts two strided arrays based on the sort order of the first array `x` using heapsort.

```javascript
var x = [ 1.0, -2.0, 3.0, -4.0 ];
var y = [ 0.0, 1.0, 2.0, 3.0 ];

gsort2hp( x.length, 1.0, x, 1, y, 1 );

console.log( x );
// => [ -4.0, -2.0, 1.0, 3.0 ]

console.log( y );
// => [ 3.0, 1.0, 0.0, 2.0 ]
```

The function has the following parameters:

-   **N**: number of indexed elements.
-   **order**: sort order. If `order < 0.0`, the input strided array `x` is sorted in **decreasing** order. If `order > 0.0`, the input strided array `x` is sorted in **increasing** order. If `order == 0.0`, the input strided arrays are left unchanged.
-   **x**: first input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
-   **strideX**: `x` index increment.
-   **y**: second input [`Array`][mdn-array] or [`typed array`][mdn-typed-array].
-   **strideY**: `y` index increment.

The `N` and `stride` parameters determine which elements in `x` and `y` are accessed at runtime. For example, to sort every other element

```javascript
var floor = require( '@stdlib/math/base/special/floor' );

var x = [ 1.0, -2.0, 3.0, -4.0 ];
var y = [ 0.0, 1.0, 2.0, 3.0 ];
var N = floor( x.length / 2 );

gsort2hp( N, -1.0, x, 2, y, 2 );

console.log( x );
// => [ 3.0, -2.0, 1.0, -4.0 ]

console.log( y );
// => [ 2.0, 1.0, 0.0, 3.0 ]
```

Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.

```javascript
var Float64Array = require( '@stdlib/array/float64' );
var floor = require( '@stdlib/math/base/special/floor' );

// Initial arrays...
var x0 = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
var y0 = new Float64Array( [ 0.0, 1.0, 2.0, 3.0 ] );

// Create offset views...
var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
var y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
var N = floor( x0.length/2 );

// Sort every other element...
gsort2hp( N, -1.0, x1, 2, y1, 2 );

console.log( x0 );
// => <Float64Array>[ 1.0, 4.0, 3.0, 2.0 ]

console.log( y0 );
// => <Float64Array>[ 0.0, 3.0, 2.0, 1.0 ]
```

#### gsort2hp.ndarray( N, order, x, strideX, offsetX, y, strideY, offsetY )

Simultaneously sorts two strided arrays based on the sort order of the first array `x` using heapsort and alternative indexing semantics.

```javascript
var x = [ 1.0, -2.0, 3.0, -4.0 ];
var y = [ 0.0, 1.0, 2.0, 3.0 ];

gsort2hp.ndarray( x.length, 1.0, x, 1, 0, y, 1, 0 );

console.log( x );
// => [ -4.0, -2.0, 1.0, 3.0 ]

console.log( y );
// => [ 3.0, 1.0, 0.0, 2.0 ]
```

The function has the following additional parameters:

-   **offsetX**: `x` starting index.
-   **offsetY**: `y` starting index.

While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying `buffer`, the `offset` parameter supports indexing semantics based on a starting index. For example, to access only the last three elements of `x`

```javascript
var x = [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ];
var y = [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 ];

gsort2hp.ndarray( 3, 1.0, x, 1, x.length-3, y, 1, y.length-3 );

console.log( x );
// => [ 1.0, -2.0, 3.0, -6.0, -4.0, 5.0 ]

console.log( y );
// => [ 0.0, 1.0, 2.0, 5.0, 3.0, 4.0 ]
```

## Notes

-   If `N <= 0` or `order == 0.0`, both functions leave `x` and `y` unchanged.
-   The algorithm distinguishes between `-0` and `+0`. When sorted in increasing order, `-0` is sorted before `+0`. When sorted in decreasing order, `-0` is sorted after `+0`.
-   The algorithm sorts `NaN` values to the end. When sorted in increasing order, `NaN` values are sorted last. When sorted in decreasing order, `NaN` values are sorted first.
-   The algorithm has space complexity `O(1)` and worst case time complexity `O(N^2)`.
-   The algorithm is efficient for **small** strided arrays (typically `N <= 20`) and is particularly efficient for sorting strided arrays which are already substantially sorted.
-   The algorithm has space complexity `O(1)` and time complexity `O(N log2 N)`.
-   The algorithm is **unstable**, meaning that the algorithm may change the order of strided array elements which are equal or equivalent (e.g., `NaN` values).
-   Depending on the environment, the typed versions ([`dsort2hp`][@stdlib/blas/ext/base/dsort2hp], [`ssort2hp`][@stdlib/blas/ext/base/ssort2hp], etc.) are likely to be significantly more performant.

## Examples

```javascript
var round = require( '@stdlib/math/base/special/round' );
var randu = require( '@stdlib/random/base/randu' );
var Float64Array = require( '@stdlib/array/float64' );
var gsort2hp = require( '@stdlib/blas/ext/base/gsort2hp' );

var rand;
var sign;
var x;
var y;
var i;

x = new Float64Array( 10 );
y = new Float64Array( 10 ); // index array
for ( i = 0; i < x.length; i++ ) {
    rand = round( randu()*100.0 );
    sign = randu();
    if ( sign < 0.5 ) {
        sign = -1.0;
    } else {
        sign = 1.0;
    }
    x[ i ] = sign * rand;
    y[ i ] = i;
}
console.log( x );
console.log( y );

gsort2hp( x.length, -1.0, x, -1, y, -1 );
console.log( x );
console.log( y );
```

* * *

## References

-   Williams, John William Joseph. 1964. "Algorithm 232: Heapsort." _Communications of the ACM_ 7 (6). New York, NY, USA: Association for Computing Machinery: 347–49. doi:[10.1145/512274.512284][@williams:1964a].
-   Floyd, Robert W. 1964. "Algorithm 245: Treesort." _Communications of the ACM_ 7 (12). New York, NY, USA: Association for Computing Machinery: 701. doi:[10.1145/355588.365103][@floyd:1964a].

[mdn-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray

[@stdlib/blas/ext/base/dsort2hp]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dsort2hp

[@stdlib/blas/ext/base/ssort2hp]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/ssort2hp

[@williams:1964a]: https://doi.org/10.1145/512274.512284

[@floyd:1964a]: https://doi.org/10.1145/355588.365103


text:
from pyramid.view import (
    view_config,
    view_defaults,
    forbidden_view_config,
)

from pyramid.httpexceptions import (
    HTTPUnauthorized,
    HTTPNotFound,
)

from .models import (
    Site,
    Page,
    Gallery,
    Image,
    NotFoundException,
    NoAccessException,
)

@view_defaults(renderer='json', permission='api')
class SiteAPI:
    def __init__(self, request):
        self.request = request

        if 'api_key' not in request.GET:
            raise HTTPUnauthorized

        try:
            site = Site.get_from_key_and_api_key(request.matchdict['site_key'], request.GET.getone('api_key'))
        except NotFoundException:
            raise HTTPNotFound
        except NoAccessException:
            raise HTTPUnauthorized

        self.site = site

    @view_config(route_name='api_site_page')
    def page(self):
        page = Page.get_for_site_id_and_page_id_or_alias(self.site.id, self.request.matchdict['page_id'])

        if not page or not page.published:
            raise HTTPNotFound

        return {
            'site': self.site,
            'page': page,
        }

    @view_config(route_name='api_site_gallery')
    def gallery(self):
        gallery = self._current_gallery()

        return {
            'site': self.site,
            'gallery': gallery,
        }

    @view_config(route_name='api_site_gallery_image')
    def gallery_image(self):
        gallery = self._current_gallery()
        image = Image.get_from_gallery_id_and_image_id(self.request.matchdict['gallery_id'], self.request.matchdict['image_id'])

        if not image:
            raise HTTPNotFound

        next_prev = {}

        if not image.parent_image_id:
            next_prev = Image.get_next_and_previous_from_image(image)

        return {
            'site': self.site,
            'gallery': gallery,
            'image': image,
            'related': image.children,
            'next': None if image.parent_image_id else next_prev['next'],
            'previous': None if image.parent_image_id else next_prev['previous'],
        }

    def _current_gallery(self):
        gallery = Gallery.get_from_site_id_and_gallery_id(self.site.id, self.request.matchdict['gallery_id'])

        if not gallery:
            raise HTTPNotFound

        return gallery


text:
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.lerx.style.vote.vo">
	<class name="VoteStyleSubElementInCommon" table="vote_style_element" dynamic-update="true">
		<id name="id" column="id">
			<generator class="native" />
		</id>

		<property name="htmlTemplate" type="text" />
		<property name="cssCode" type="text" />
		<property name="htmlCode" type="text" />
		<property name="topCode" type="text" />
		<property name="footerCode" type="text" />
		<property name="memberPanelCodeForLogIn" type="text" />
		<property name="memberPanelCodeForLogOut" type="text" />

		<property name="itemsLoopFormat" type="text" />
		<property name="lineCodeFormat" type="text" />

		<property name="titleFormat"></property>
		<property name="hrefLineFormat" type="text"></property>

		<property name="specialCode1" type="text"></property>
		<property name="specialCode2" type="text"></property>
		<property name="specialCode3" type="text"></property>
		<property name="specialCode4" type="text"></property>
	</class>

</hibernate-mapping>


text:
L.MAP2U.legend = function (options) {
  var control = L.control(options);

  control.onAdd = function (map) {
    var $container = $('
')
      .attr('class', 'leaflet-control');

    var button = $('')
      .attr('class', 'control-button')
      .attr('href', '#')
      .html('')
      .on('click', toggle)
      .appendTo($container);

    var $ui = $('
')
      .attr('class', 'key-ui');

    $('
')
      .attr('class', 'sidebar_heading')
      .appendTo($ui)
      .append(
        $('
')
          .text(I18n.t('javascripts.key.title')));
    var barContent = $('
')
         .attr('class', 'sidebar_content')
         .appendTo($ui)

    var $section = $('
')
      .attr('class', 'section')
      .appendTo(barContent);

    list = $('
')
      .appendTo($section);

    map.dataLayers.forEach(function(layer) {
//        var item = $('
')
//        .appendTo(list);
//

            if (layer.layer !== null && layer.layer !== undefined && layer.layer.options !== undefined)
            {
          //      list.append('
' + layer.name);
          //      list.append('
');
          //      list.append("");
          //      list.append('
');
          //      list.append('
');
            }

//        item.append(layer.name);
//        item.append(""+layer.layer.options.layers+"");

    });
    options.sidebar.addPane($ui);
    jQuery(window).resize(function() {
        barContent.height($('.leaflet-sidebar.right').height()-70);
    });
//    $ui
//      .on('show', shown)
//      .on('hide', hidden);

//    map.on('overlayschange', updateButton);
//
//    updateButton();
//
//    function shown() {
//      map.on('zoomend baselayerchange', update);
//      $section.load('/key', update);
//    }
//
//    function hidden() {
//      map.off('zoomend baselayerchange', update);
//    }

    function toggle(e) {
      e.stopPropagation();
      e.preventDefault();
      if (!button.hasClass('disabled')) {
        options.sidebar.togglePane($ui, button);
      }
      $('.leaflet-control .control-button').tooltip('hide');
    }

    function updateButton() {
      var disabled = false;//map.getMapBaseLayerId() !== 'mapnik'
      button
        .toggleClass('disabled', disabled)
        .attr('data-original-title', I18n.t(disabled ?
          'javascripts.key.tooltip_disabled' :
          'javascripts.key.tooltip'))
    }

    function update() {
      var layer = map.getMapBaseLayerId(),
        zoom = map.getZoom();

//      $('.mapkey-table-entry').each(function () {
//        var data = $(this).data();
//        if (layer == data.layer && zoom >= data.zoomMin && zoom <= data.zoomMax) {
//          $(this).show();
//        } else {
//          $(this).hide();
//        }
//      });
    }

    return $container[0];
  };

  return control;
};


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NuGet.Configuration;
using NuGet.PackageManagement;
using NuGet.Packaging.Core;
using NuGet.ProjectManagement;
using NuGet.Protocol;
using NuGet.Protocol.Core.Types;
using NuGet.Resolver;
using NuGet.Versioning;

namespace nuget2bazel
{
    public class AddCommand
    {
        public Task Do(ProjectBazelConfig prjConfig, string package, string version, string mainFile, bool skipSha256, bool lowest, string variable)
        {
            var project = new ProjectBazelManipulator(prjConfig, mainFile, skipSha256, variable);

            if(prjConfig.ProjectFiles != null)
            {
                var projectFileParser = new ProjectFileParser(prjConfig);
                var packages = projectFileParser.GetNugetPackages();

                var nugetTasks = packages.Select(p => DoWithProject(prjConfig.NugetSource, p.Name, p.Version, project, lowest)).ToArray();

                return Task.WhenAll(nugetTasks);
            }

            return DoWithProject(prjConfig.NugetSource, package, version, project, lowest);
        }
        public async Task DoWithProject(string nugetSource, string package, string version, ProjectBazelManipulator project, bool lowest)
        {
            var logger = new Logger();
            var providers = new List<Lazy<INuGetResourceProvider>>();
            providers.AddRange(Repository.Provider.GetCoreV3());  // Add v3 API support
            var packageSource = new PackageSource(nugetSource);
            var sourceRepository = new SourceRepository(packageSource, providers);
            var packageMetadataResource = await sourceRepository.GetResourceAsync<PackageMetadataResource>();
            var verParsed = NuGetVersion.Parse(version);
            var identity = new NuGet.Packaging.Core.PackageIdentity(package, verParsed);
            var content = new SourceCacheContext();
            var found = await packageMetadataResource.GetMetadataAsync(identity, content, logger, CancellationToken.None);

            //var settings = Settings.LoadDefaultSettings(project.ProjectConfig.RootPath, null, new MachineWideSettings());
            var settings = Settings.LoadDefaultSettings(project.ProjectConfig.RootPath, null, null);
            var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers);
            var packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, project.ProjectConfig.RootPath)
            {
                PackagesFolderNuGetProject = project
            };

            const bool allowPrereleaseVersions = false;
            const bool allowUnlisted = false;
            var resolutionContext = new ResolutionContext(
                lowest ? DependencyBehavior.Lowest : DependencyBehavior.HighestMinor, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None);

            var projectContext = new ProjectContext(settings);

            var actions = await packageManager.PreviewInstallPackageAsync(packageManager.PackagesFolderNuGetProject,
                identity, resolutionContext, projectContext, sourceRepository,
                sourceRepositoryProvider.GetRepositories(),
                CancellationToken.None);
            project.NuGetProjectActions = actions;

            await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
                identity, resolutionContext, projectContext, sourceRepository,
                sourceRepositoryProvider.GetRepositories(),
                CancellationToken.None);

            NuGetPackageManager.ClearDirectInstall(projectContext);

        }
    }
}


text:
package org.jboss.weld.tests.proxy.weld1664;

import jakarta.inject.Inject;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.Archive;
import org.jboss.shrinkwrap.api.BeanArchive;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.weld.test.util.Utils;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(Arquillian.class)
public class InterfaceStaticMethodProxyTest {

    @Inject
    Bar bar;

    @Deployment
    public static Archive<?> getDeployment() {
        return ShrinkWrap.create(BeanArchive.class, Utils.getDeploymentNameAsHash(InterfaceStaticMethodProxyTest.class)).addPackage(InterfaceStaticMethodProxyTest.class.getPackage());
    }

    @Test
    public void test() {
        Assert.assertNotNull(bar);
    }
}


text:
Next.js ships with [styled-jsx](https://github.com/vercel/styled-jsx) allowing you
to write scope styled components with full css support. This is important for
the modularity and code size of your bundles and also for the learning curve of the framework. If you know css you can write styled-jsx right away.

This example shows how to configure styled-jsx to use external plugins to modify the output. Using this you can use PostCSS, SASS (SCSS), LESS, or any other pre-processor with styled-jsx. You can define plugins in `.babelrc`. This example shows how to implement the SASS plugin.

More details about how plugins work can be found in the [styled-jsx readme](https://github.com/vercel/styled-jsx#css-preprocessing-via-plugins)

## Deploy your own

Deploy the example using [Vercel](https://vercel.com?utm_source=github&utm_medium=readme&utm_campaign=next-example) or preview live with [StackBlitz](https://stackblitz.com/github/vercel/next.js/tree/canary/examples/with-styled-jsx-scss)

[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/git/external?repository-url=https://github.com/vercel/next.js/tree/canary/examples/with-styled-jsx-scss&project-name=with-styled-jsx-scss&repository-name=with-styled-jsx-scss)

## How to use

Execute [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app) with [npm](https://docs.npmjs.com/cli/init), [Yarn](https://yarnpkg.com/lang/en/docs/cli/create/), or [pnpm](https://pnpm.io) to bootstrap the example:

```bash
npx create-next-app --example with-styled-jsx-scss with-styled-jsx-scss-app
```

```bash
yarn create next-app --example with-styled-jsx-scss with-styled-jsx-scss-app
```

```bash
pnpm create next-app --example with-styled-jsx-scss with-styled-jsx-scss-app
```

Deploy it to the cloud with [Vercel](https://vercel.com/new?utm_source=github&utm_medium=readme&utm_campaign=next-example) ([Documentation](https://nextjs.org/docs/deployment)).


text:
require('./Animate.less');
var React = require('react');
var ReactDOM = require('react-dom');

module.exports = React.createClass({
	displayName:'Animate',
	getDefaultProps: function (){
		return {
			in: 'zn-animate-move-from-right',
			out: 'zn-animate-move-to-right',
			onTop: true,
			className: null,
			onIn: function (){},
			onOut: function (){}
		};
	},
	getInitialState: function (){
		return {
			active: false,
			animating: false,
			animation: ''
		};
	},
	componentDidMount: function (){
		var dom = ReactDOM.findDOMNode(this);
		dom.addEventListener("animationend", this.__onAnimationEnd, false);
		dom.addEventListener("oAnimationEnd", this.__onAnimationEnd, false);
		dom.addEventListener("MSAnimationEnd", this.__onAnimationEnd, false);
		dom.addEventListener("webkitAnimationEnd", this.__onAnimationEnd, false);
	},
	__onAnimationEnd: function (){
		this.setState({
			animation: '',
			animating: false
		}, function (){
			if(this.state.active){
				this.props.onIn && this.props.onIn(this);
			}else {
				this.props.onOut && this.props.onOut(this);
			}
		}.bind(this));
	},
	in: function (animation, onIn){
		this.state.animating = true;
		this.state.active = true;
		return this.setState({
			animation: animation || this.props.in
		}), this;
	},
	out: function (animation, onOut){
		this.state.animating = true;
		this.state.active = false;
		return this.setState({
			animation: animation || this.props.out,
		}), this;
	},
	render: function(){
		return (
			<div className={zn.react.classname(
					"zr-animate",
					((this.state.active||this.state.animating)?'active':''),
					((!!this.props.onTop&&this.state.animation)?'ontop':''),
					this.props.className,
					this.state.animation
				)}>
				{this.props.children}
			</div>
		);
	}
});


text:
package com.xiaogua.better.algorithm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

public class TestQueryDataByPage {
	@Test
	public void testGetQueryTblList() {
		List<String> monthList = new ArrayList<String>();
		monthList.add("201601");
		monthList.add("201602");
		monthList.add("201603");
		monthList.add("201604");
		monthList.add("201605");
		monthList.add("201606");
		monthList.add("201607");
		int[] numArr = new int[] { 1, 31, 0, 6, 1, 4, 7 };
		LinkedHashMap<String, Integer[]> rtnMap = QueryDataByPage.getQueryTblList(monthList, 40, 7, numArr);
		for (Map.Entry<String, Integer[]> entry : rtnMap.entrySet()) {
			System.out.println(entry.getKey() + "," + Arrays.toString(entry.getValue()));
		}
	}
}


text:
ig.module('game.entities.melee')
.requires('game.entities.physEnt')
.defines(function() {
	EntityMelee = EntityPhysEnt.extend({
		animSheet: new ig.AnimationSheet('media/meleesheet.png', 10, 10),
		size: {x: 10, y:10},
		offset: {x: 0, y:0},
		categoryBits: ig.Filter.FRIENDLY,
		maskBits: ig.Filter.ENEMY, // + non-enemy environment stuff, but ENVIRON is currently only for solid tiles
		meleeTimer: new ig.Timer(),
		lifetime: 0.5,
		dmg: 1,
		density: 0.1,
		maxVel: {x: 75, y: 300},
		flip: false,
		meleePushImpulse: 100, //how far melee flings you forward. Should make sure this is, overall, less than you could traverse while walking/running in the lifetime of the punch, or else it's a movement exploit
		meleeHitImpulse: 40, //how hard melee flings an enemy when hit.
		gravityFactor: 0,
		origin: null,

		//we're going to weld this to the player, so no need for fancy updating
		init: function(x,y, settings) {
			this.parent(x,y,settings);
			this.flip = settings.flip;
			this.origin = settings.origin;
			this.meleeTimer.set(0);
			this.currentAnim.flip.x = this.flip;
		},

		update: function() {
			if (this.meleeTimer.delta() >= this.lifetime) {
				this.kill();
				this.origin.dimChange('normal');
			}
			this.currentAnim.flip.x = this.flip;
			this.parent();
		},

		beginContact: function(other, contact) {
			if (other && other.receiveDamage && contact.GetManifold().m_pointCount > 0 ) {
				other.receiveDamage(this.dmg);
				var fixThis, othFix, worldMan, manifoldNorm, contactPoint;
				worldMan = new Box2D.Collision.b2WorldManifold();
				if (contact.GetFixtureA().GetBody().entity == this) {
					fixThis = contact.GetFixtureA();
					othFix = contact.GetFixtureB();
					contact.GetWorldManifold(worldMan);
					manifoldNorm = worldMan.m_normal;
					//piecewise report
					//console.log("Local point: ", contact.GetManifold().m_points[0].m_localPoint);
					//console.log("World Point: ", this.body.GetWorldPoint(contact.GetManifold().m_points[0].m_localPoint));
					//console.log("New local point: ", other.body.GetLocalPoint(this.body.GetWorldPoint(contact.GetManifold().m_points[0].m_localPoint)));
					contactPoint = other.body.GetLocalPoint(worldMan.m_points[0]);
				}
				else {
					fixThis = contact.GetFixtureB();
					othFix = contact.GetFixtureA();
					worldMan = contact.GetWorldManifold(worldMan);
					manifoldNorm = worldMan.m_normal.Copy().NegativeSelf();
					contactPoint = other.body.GetLocalPoint(worldMan.m_points[0]);
				}
				manifoldNorm.Normalize();
				//console.log(manifoldNorm);
				//console.log(contactPoint);
				//debug draw

				var ctx = ig.system.context;
				 var begin = other.body.GetPosition().Copy();
				 var end = contactPoint.Copy();
				 ig.game.contactStart = begin;
				 ig.game.contactEnd = other.body.GetWorldPoint(end);
				 ig.game.contactDraw = true;
				ctx.strokeStyle = 'rgba(255,0,0,1)';

				 ctx.beginPath();
				 ctx.moveTo(ig.system.getDrawPos(other.body.GetPosition().x/Box2D.SCALE - ig.game.screen.x), ig.system.getDrawPos(other.body.GetPosition().y/Box2D.SCALE - ig.game.screen.y));
				 ctx.lineTo(ig.system.getDrawPos(other.body.GetWorldPoint(contactPoint).x/Box2D.SCALE - ig.game.screen.x), ig.system.getDrawPos(other.body.GetWorldPoint(contactPoint).y/Box2D.SCALE - ig.game.screen.y));
				 ctx.stroke();
				console.log(manifoldNorm);
				console.log(worldMan.m_points[0]);
				other.body.ApplyImpulse(new Box2D.Common.Math.b2Vec2(this.meleeHitImpulse*manifoldNorm.x, this.meleeHitImpulse*manifoldNorm.y), worldMan.m_points[0]); // lol. Need to learn appropriate application of forces...

			}
		},

		setupAnimation: function() {
			this.addAnim('idle', this.lifetime/6, [0,1,2]);
		},

	});
});


text:
<resources>
  <!-- Default screen margins, per the Android Design guidelines. -->
  <dimen name="activity_horizontal_margin">16dp</dimen>
  <dimen name="activity_vertical_margin">16dp</dimen>

  <dimen name="item_ebook_width">100dp</dimen>
  <dimen name="item_ebook_height">150dp</dimen>

  <dimen name="detail_backdrop_height">256dp</dimen>
  <dimen name="card_margin">16dp</dimen>

</resources>


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <title>Be MEAN</title>

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.6/css/materialize.min.css">
    <link rel="stylesheet" href="styles.css">

{{ User.titulo }}

        <select data-ng-options="user.email as user.name for user in User.users" data-ng-model="User.selected">
            <option value="">Escolha um usuário</option>
        </select>

{{User.selected}}

                <input type="text" data-ng-model="User.form.name" placeholder="Name" data-ng-model-options="{ getterSetter: true }">

                <input type="email" data-ng-model="User.form.email" placeholder="Email" data-ng-model-options="{ allowInvalid: true }">

                <input type="TIME" data-ng-model="User.form.date" data-ng-model-options="{ timezone: 'UTC' }">

        <button data-ng-disabled="User.editing" data-ng-click="User.add(User.form)" class="btn btn-large green waves-effect waves-light col s12" type="submit" name="action">Add</button>
        <button data-ng-disabled="!User.editing" data-ng-click="User.save(User.form)" class="btn btn-large animate blue waves-effect waves-light col s12" type="submit" name="action">Save</button>

                            <input data-ng-model="searchUser" data-ng-model-options="{ updateOn: 'blur default', debounce: { default: 3000, blur: 0} }" placeholder="Search">

                    Name
                    Email

                        <input type="checkbox" id="user-{{$index}}" ng-model="user.selecionado" />

                    {{ user.name }}
                    {{ user.email }}

                        <button data-ng-click="User.edit(user, $index)" class="btn blue waves-effect waves-light col s12" type="submit" name="action">Edit</button>


text:
/*
* TLS Server Proxy
* (C) 2014,2015,2019 Jack Lloyd
* (C) 2016 Matthias Gierlings
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "cli.h"

#if defined(BOTAN_HAS_TLS) && defined(BOTAN_HAS_BOOST_ASIO) && defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)

#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <atomic>

#define _GLIBCXX_HAVE_GTHR_DEFAULT
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <botan/internal/os_utils.h>

#include <botan/tls_server.h>
#include <botan/x509cert.h>
#include <botan/pkcs8.h>
#include <botan/hex.h>
#include <botan/rng.h>

#if defined(BOTAN_HAS_TLS_SQLITE3_SESSION_MANAGER)
   #include <botan/tls_session_manager_sqlite.h>
#endif

#include "tls_helpers.h"

#if BOOST_VERSION >= 107000
#define GET_IO_SERVICE(s) (static_cast<boost::asio::io_context&>((s).get_executor().context()))
#else
#define GET_IO_SERVICE(s) ((s).get_io_service())
#endif

namespace Botan_CLI {

namespace {

using boost::asio::ip::tcp;

void log_exception(const char* where, const std::exception& e)
   {
   std::cout << where << ' ' << e.what() << std::endl;
   }

void log_error(const char* where, const boost::system::error_code& error)
   {
   std::cout << where << ' ' << error.message() << std::endl;
   }

void log_binary_message(const char* where, const uint8_t buf[], size_t buf_len)
   {
   BOTAN_UNUSED(where, buf, buf_len);
   //std::cout << where << ' ' << Botan::hex_encode(buf, buf_len) << std::endl;
   }

void log_text_message(const char* where,  const uint8_t buf[], size_t buf_len)
   {
   BOTAN_UNUSED(where, buf, buf_len);
   //const char* c = reinterpret_cast<const char*>(buf);
   //std::cout << where << ' ' << std::string(c, c + buf_len)  << std::endl;
   }

class ServerStatus
   {
   public:
      ServerStatus(size_t max_clients) : m_max_clients(max_clients), m_clients_serviced(0) {}

      bool should_exit() const
         {
         if(m_max_clients == 0)
            return false;

         return clients_serviced() >= m_max_clients;
         }

      void client_serviced() { m_clients_serviced++; }

      size_t clients_serviced() const { return m_clients_serviced.load(); }
   private:
      size_t m_max_clients;
      std::atomic<size_t> m_clients_serviced;
   };

class tls_proxy_session final : public std::enable_shared_from_this<tls_proxy_session>,
                                public Botan::TLS::Callbacks
   {
   public:
      enum { readbuf_size = 17 * 1024 };

      typedef std::shared_ptr<tls_proxy_session> pointer;

      static pointer create(
         boost::asio::io_service& io,
         Botan::TLS::Session_Manager& session_manager,
         Botan::Credentials_Manager& credentials,
         Botan::TLS::Policy& policy,
         tcp::resolver::iterator endpoints)
         {
         return std::make_shared<tls_proxy_session>(
            io,
            session_manager,
            credentials,
            policy,
            endpoints
            );
         }

      tcp::socket& client_socket()
         {
         return m_client_socket;
         }

      void start()
         {
         m_c2p.resize(readbuf_size);
         client_read(boost::system::error_code(), 0); // start read loop
         }

      void stop()
         {
         if(m_is_closed == false)
            {
            /*
            Don't need to talk to the server anymore
            Client socket is closed during write callback
            */
            m_server_socket.close();
            m_tls.close();
            m_is_closed = true;
            }
         }

      tls_proxy_session(
         boost::asio::io_service& io,
         Botan::TLS::Session_Manager& session_manager,
         Botan::Credentials_Manager& credentials,
         Botan::TLS::Policy& policy,
         tcp::resolver::iterator endpoints)
         : m_strand(io)
         , m_server_endpoints(endpoints)
         , m_client_socket(io)
         , m_server_socket(io)
         , m_rng(cli_make_rng())
         , m_tls(*this,
                 session_manager,
                 credentials,
                 policy,
                 *m_rng) {}

   private:
      void client_read(const boost::system::error_code& error,
                       size_t bytes_transferred)
         {
         if(error)
            {
            log_error("Read failed", error);
            stop();
            return;
            }

         try
            {
            if(!m_tls.is_active())
               {
               log_binary_message("From client", &m_c2p[0], bytes_transferred);
               }
            m_tls.received_data(&m_c2p[0], bytes_transferred);
            }
         catch(Botan::Exception& e)
            {
            log_exception("TLS connection failed", e);
            stop();
            return;
            }

         m_client_socket.async_read_some(
            boost::asio::buffer(&m_c2p[0], m_c2p.size()),
            m_strand.wrap(
               boost::bind(
                  &tls_proxy_session::client_read, shared_from_this(),
                  boost::asio::placeholders::error,
                  boost::asio::placeholders::bytes_transferred)));
         }

      void handle_client_write_completion(const boost::system::error_code& error)
         {
         if(error)
            {
            log_error("Client write", error);
            stop();
            return;
            }

         m_p2c.clear();

         if(m_p2c_pending.empty() && m_tls.is_closed())
            {
            m_client_socket.close();
            }
         tls_emit_data(nullptr, 0); // initiate another write if needed
         }

      void handle_server_write_completion(const boost::system::error_code& error)
         {
         if(error)
            {
            log_error("Server write", error);
            stop();
            return;
            }

         m_p2s.clear();
         proxy_write_to_server(nullptr, 0); // initiate another write if needed
         }

      void tls_record_received(uint64_t /*rec_no*/, const uint8_t buf[], size_t buf_len) override
         {
         // Immediately bounce message to server
         proxy_write_to_server(buf, buf_len);
         }

      void tls_emit_data(const uint8_t buf[], size_t buf_len) override
         {
         if(buf_len > 0)
            {
            m_p2c_pending.insert(m_p2c_pending.end(), buf, buf + buf_len);
            }

         // no write now active and we still have output pending
         if(m_p2c.empty() && !m_p2c_pending.empty())
            {
            std::swap(m_p2c_pending, m_p2c);

            log_binary_message("To Client", &m_p2c[0], m_p2c.size());

            boost::asio::async_write(
               m_client_socket,
               boost::asio::buffer(&m_p2c[0], m_p2c.size()),
               m_strand.wrap(
                  boost::bind(
                     &tls_proxy_session::handle_client_write_completion,
                     shared_from_this(),
                     boost::asio::placeholders::error)));
            }
         }

      void proxy_write_to_server(const uint8_t buf[], size_t buf_len)
         {
         if(buf_len > 0)
            {
            m_p2s_pending.insert(m_p2s_pending.end(), buf, buf + buf_len);
            }

         // no write now active and we still have output pending
         if(m_p2s.empty() && !m_p2s_pending.empty())
            {
            std::swap(m_p2s_pending, m_p2s);

            log_text_message("To Server", &m_p2s[0], m_p2s.size());

            boost::asio::async_write(
               m_server_socket,
               boost::asio::buffer(&m_p2s[0], m_p2s.size()),
               m_strand.wrap(
                  boost::bind(
                     &tls_proxy_session::handle_server_write_completion,
                     shared_from_this(),
                     boost::asio::placeholders::error)));
            }
         }

      void server_read(const boost::system::error_code& error,
                       size_t bytes_transferred)
         {
         if(error)
            {
            log_error("Server read failed", error);
            stop();
            return;
            }

         try
            {
            if(bytes_transferred)
               {
               log_text_message("Server to client", &m_s2p[0], m_s2p.size());
               log_binary_message("Server to client", &m_s2p[0], m_s2p.size());
               m_tls.send(&m_s2p[0], bytes_transferred);
               }
            }
         catch(Botan::Exception& e)
            {
            log_exception("TLS connection failed", e);
            stop();
            return;
            }

         m_s2p.resize(readbuf_size);

         m_server_socket.async_read_some(
            boost::asio::buffer(&m_s2p[0], m_s2p.size()),
            m_strand.wrap(
               boost::bind(&tls_proxy_session::server_read, shared_from_this(),
                           boost::asio::placeholders::error,
                           boost::asio::placeholders::bytes_transferred)));
         }

      bool tls_session_established(const Botan::TLS::Session& session) override
         {
         m_hostname = session.server_info().hostname();

         auto onConnect = [this](boost::system::error_code ec, tcp::resolver::iterator /*endpoint*/)
            {
            if(ec)
               {
               log_error("Server connection", ec);
               return;
               }
            server_read(boost::system::error_code(), 0); // start read loop
            proxy_write_to_server(nullptr, 0);
            };
         async_connect(m_server_socket, m_server_endpoints, onConnect);
         return true;
         }

      void tls_alert(Botan::TLS::Alert alert) override
         {
         if(alert.type() == Botan::TLS::Alert::CLOSE_NOTIFY)
            {
            m_tls.close();
            return;
            }
         }

      boost::asio::io_service::strand m_strand;

      tcp::resolver::iterator m_server_endpoints;

      tcp::socket m_client_socket;
      tcp::socket m_server_socket;

      std::unique_ptr<Botan::RandomNumberGenerator> m_rng;
      Botan::TLS::Server m_tls;
      std::string m_hostname;

      std::vector<uint8_t> m_c2p;
      std::vector<uint8_t> m_p2c;
      std::vector<uint8_t> m_p2c_pending;

      std::vector<uint8_t> m_s2p;
      std::vector<uint8_t> m_p2s;
      std::vector<uint8_t> m_p2s_pending;

      bool m_is_closed = false;
   };

class tls_proxy_server final
   {
   public:
      typedef tls_proxy_session session;

      tls_proxy_server(
         boost::asio::io_service& io, unsigned short port,
         tcp::resolver::iterator endpoints,
         Botan::Credentials_Manager& creds,
         Botan::TLS::Policy& policy,
         Botan::TLS::Session_Manager& session_mgr,
         size_t max_clients)
         : m_acceptor(io, tcp::endpoint(tcp::v4(), port))
         , m_server_endpoints(endpoints)
         , m_creds(creds)
         , m_policy(policy)
         , m_session_manager(session_mgr)
         , m_status(max_clients)
         {
         session::pointer new_session = make_session();

         m_acceptor.async_accept(
            new_session->client_socket(),
            boost::bind(
               &tls_proxy_server::handle_accept,
               this,
               new_session,
               boost::asio::placeholders::error));
         }

   private:
      session::pointer make_session()
         {
         return session::create(
                   GET_IO_SERVICE(m_acceptor),
                   m_session_manager,
                   m_creds,
                   m_policy,
                   m_server_endpoints);
         }

      void handle_accept(session::pointer new_session,
                         const boost::system::error_code& error)
         {
         if(!error)
            {
            new_session->start();
            new_session = make_session();

            m_status.client_serviced();

            if(m_status.should_exit() == false)
               {
               m_acceptor.async_accept(
                  new_session->client_socket(),
                  boost::bind(
                     &tls_proxy_server::handle_accept,
                     this,
                     new_session,
                     boost::asio::placeholders::error));
               }
            }
         }

      tcp::acceptor m_acceptor;
      tcp::resolver::iterator m_server_endpoints;

      Botan::Credentials_Manager& m_creds;
      Botan::TLS::Policy& m_policy;
      Botan::TLS::Session_Manager& m_session_manager;
      ServerStatus m_status;
   };

}

class TLS_Proxy final : public Command
   {
   public:
      TLS_Proxy() : Command("tls_proxy listen_port target_host target_port server_cert server_key "
                               "--policy=default --threads=0 --max-clients=0 --session-db= --session-db-pass=") {}

      std::string group() const override
         {
         return "tls";
         }

      std::string description() const override
         {
         return "Proxies requests between a TLS client and a TLS server";
         }

      size_t thread_count() const
         {
         if(size_t t = get_arg_sz("threads"))
            return t;
         if(size_t t = Botan::OS::get_cpu_available())
            return t;
         return 2;
         }

      void go() override
         {
         const uint16_t listen_port = get_arg_u16("listen_port");
         const std::string target = get_arg("target_host");
         const std::string target_port = get_arg("target_port");

         const std::string server_crt = get_arg("server_cert");
         const std::string server_key = get_arg("server_key");

         const size_t num_threads = thread_count();
         const size_t max_clients = get_arg_sz("max-clients");

         Basic_Credentials_Manager creds(server_crt, server_key);

         auto policy = load_tls_policy(get_arg("policy"));

         boost::asio::io_service io;

         tcp::resolver resolver(io);
         auto server_endpoint_iterator = resolver.resolve({ target, target_port });

         std::unique_ptr<Botan::TLS::Session_Manager> session_mgr;

#if defined(BOTAN_HAS_TLS_SQLITE3_SESSION_MANAGER)
         const std::string sessions_passphrase = get_passphrase_arg("Session DB passphrase", "session-db-pass");
         const std::string sessions_db = get_arg("session-db");

         if(!sessions_db.empty())
            {
            session_mgr.reset(new Botan::TLS::Session_Manager_SQLite(sessions_passphrase, rng(), sessions_db));
            }
#endif
         if(!session_mgr)
            {
            session_mgr.reset(new Botan::TLS::Session_Manager_In_Memory(rng()));
            }

         tls_proxy_server server(io, listen_port, server_endpoint_iterator, creds, *policy, *session_mgr, max_clients);

         std::vector<std::shared_ptr<std::thread>> threads;

         // run forever... first thread is main calling io.run below
         for(size_t i = 2; i <= num_threads; ++i)
            {
            threads.push_back(std::make_shared<std::thread>([&io]() { io.run(); }));
            }

         io.run();

         for(size_t i = 0; i < threads.size(); ++i)
            {
            threads[i]->join();
            }
         }
   };

BOTAN_REGISTER_COMMAND("tls_proxy", TLS_Proxy);

}

#endif