text:
package org.cocos2d.nodes;

import java.util.ArrayList;

import javax.microedition.khronos.opengles.GL10;

import org.cocos2d.types.CGPoint;

/** CCParallaxNode: A node that simulates a parallax scroller
 * The children will be moved faster / slower than the parent according the the parallax ratio.
 */
public class CCParallaxNode extends CCNode {

    /** array that holds the offset / ratio of the children */
    private ArrayList<CCPointObject> parallaxArray_;
    private CGPoint lastPosition;

    static class CCPointObject {
        private float ratioX_;
        private float ratioY_;
        private float offsetX_;
        private float offsetY_;
        private CCNode child_;

        public CCPointObject(float ratioX, float ratioY, float offsetX, float offsetY) {
            ratioX_ = ratioX;
            ratioY_ = ratioY;
            offsetX_ = offsetX;
            offsetY_ = offsetY;
        }

        public CCNode getChild() {
            return child_;
        }

        public void setChild(CCNode child) {
            child_ = child;
        }

        public float getRatioX() {
            return ratioX_;
        }

        public float getRatioY() {
            return ratioY_;
        }

        public float getOffsetX() {
            return offsetX_;
        }

        public float getOffsetY() {
            return offsetY_;
        }
    }

    public static CCParallaxNode node() {
        return new CCParallaxNode();
    }

    protected CCParallaxNode() {
        parallaxArray_ = new ArrayList<CCPointObject>(5);
        lastPosition = CGPoint.make(-100,-100);
    }

    @Override
    public CCNode addChild(CCNode child, int z, int tag) {
        assert false : "ParallaxNode: use addChild:z:parallaxRatio:positionOffset instead";
        return null;
    }

    /** Adds a child to the container with a z-order, a parallax ratio and a position offset
    It returns self, so you can chain several addChilds.
    @since v0.8
    */
    public CCNode addChild(CCNode child, int z,
    		float ratioX, float ratioY, float offsetX, float offsetY) {
        assert child != null : "Argument must be non-null";
        CCPointObject obj = new CCPointObject(ratioX, ratioY, offsetX, offsetY);
        obj.setChild(child);
        parallaxArray_.add(obj);

        CGPoint pnt = getPosition();
        float x = pnt.x * ratioX + offsetX;
        float y = pnt.y * ratioY + offsetY;
        child.setPosition(CGPoint.make(x, y));

        return super.addChild(child, z, child.getTag());
    }

    @Override
    public void removeChild(CCNode node, boolean cleanup) {
        for( int i=0;i < parallaxArray_.size();i++) {
            CCPointObject point = parallaxArray_.get(i);
            if( point.getChild().equals(node) ) {
                parallaxArray_.remove(i);
                break;
            }
        }
        super.removeChild(node, cleanup);
    }

    @Override
    public void removeAllChildren(boolean cleanup) {
        parallaxArray_.clear();
        super.removeAllChildren(cleanup);
    }

    private CGPoint absolutePosition() {
        CGPoint ret = getPosition();
        CCNode cn = this;

        while (cn.parent_ != null) {
            cn = cn.parent_;
            CGPoint pnt = cn.getPosition();
            ret.x += pnt.x;
            ret.y += pnt.y;
        }

        return ret;
    }

    /*
     The positions are updated at visit because:
       - using a timer is not guaranteed that it will called after all the positions were updated
       - overriding "draw" will only precise if the children have a z > 0
    */
    @Override
    public void visit(GL10 gl) {
        CGPoint pos = absolutePosition();
        if( ! CGPoint.equalToPoint(pos, lastPosition) ) {
            for(int i=0; i < parallaxArray_.size(); i++ ) {
                CCPointObject point = parallaxArray_.get(i);
                float x = -pos.x + pos.x * point.getRatioX() + point.getOffsetX();
                float y = -pos.y + pos.y * point.getRatioY() + point.getOffsetY();
                point.getChild().setPosition(CGPoint.make(x, y));
            }

            lastPosition = pos;
        }

        super.visit(gl);
    }

}


text:
#include "echo.pb.h"
#include "echo_opcode.h"

using namespace minirpc;

class EchoServiceImpl : public echo::EchoService
{
 public:
  EchoServiceImpl()
  {
  };

  virtual void Echo(::google::protobuf::RpcController* controller,
                    const ::echo::EchoRequest* request,
                    ::echo::EchoResponse* response,
                    ::google::protobuf::Closure* done)
 {
    LOG(INFO) << "request: " << request->message();

    response->set_response(request->message());
    if (done)
	{
      done->Run();
    }
  }
  virtual void Dummy(::google::protobuf::RpcController* controller,
                     const ::echo::DummyRequest* request,
                     ::echo::DummyResponse* response,
                     ::google::protobuf::Closure* done)
  {
    LOG(INFO) << "dummy request: " << request->message();
    if (done)
	{
      done->Run();
    }
  }
};

int main(int argc, char *argv[])
{
  google::InitGoogleLogging(argv[0]);
  Mutex mutex1,mutex2;
  Condition monitor1(mutex1);
	Condition monitor2(mutex2);
	Mutex mutex3,mutex4;
  Condition monitor3(mutex3);
	Condition monitor4(mutex4);
	std::vector<ReactorLoop*> loop;
	ReactorLoop* loop1_=new ReactorLoop();
  loop1_->startInOtherThread(&monitor1);
	loop.push_back(loop1_);
	ReactorLoop* loop2_=new ReactorLoop();
  loop2_->startInOtherThread(&monitor2);
	loop.push_back(loop2_);
  ReactorLoop* loop3_=new ReactorLoop();
  loop3_->startInOtherThread(&monitor3);
	loop.push_back(loop3_);
	ReactorLoop* loop4_=new ReactorLoop();
  loop4_->startInOtherThread(&monitor4);
	loop.push_back(loop4_);

  monitor1.wait();
	monitor2.wait();
	monitor3.wait();
	monitor4.wait();
  std::string host="127.0.0.1";
  int port=22829;
	::google::protobuf::Service *service = new EchoServiceImpl();
	RpcServiceServer server(loop,host, port);
	server.RegisterService(service);
	server.start();
  //just stop in here
  int n;
  std::cin>> n;
  return 0;
}

redpajama_set_name: RedPajamaGithub


text:
from .probability import BaseProbabilityCollector
from .itemcount import ItemCountCollector
from .itemfrequency import ItemFrequencyCollector

class ItemProbabilityCollector(BaseProbabilityCollector):

	result_dependencies = (ItemCountCollector, ItemFrequencyCollector)


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

<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.15"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>SDK: Member List</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>

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

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

SDK
    Release 1.8.3

Communications, logger, and bootloader libraries.

cISFileStream Member List

This is the complete list of members for cISFileStream, including all inherited members.

cISFileStream()	cISFileStream

cISStream()	cISStream	inline

Close() OVERRIDE	cISFileStream	virtual

Eof()	cISFileStream

Flush() OVERRIDE	cISFileStream	virtual

GetBytesAvailableToRead() OVERRIDE	cISFileStream	virtual

Open(const std::string &path, const char *mode)	cISFileStream

Read(void *buffer, int count) OVERRIDE	cISFileStream	virtual

Write(const void *buffer, int count) OVERRIDE	cISFileStream	virtual

~cISStream()	cISStream	virtual

<address class="footer">
Generated by

 1.8.15
</address>


text:
#include "main.h"
#include <assert.h>

#include "pushpack1.h"

namespace {

// Data structure for the first header of a BMP
struct BITMAPFILEHEADER
{
	uint16_t  bfType ;
	uint32_t  bfSize;
	uint16_t  bfReserved1 ;
	uint16_t  bfReserved2;
	uint32_t  bfOffBits;
} PACK_STRUCT;

// Data structure for the second header of a BMP
struct BITMAPINFOHEADER
{
	int32_t        biSize;
	int32_t        biWidth;
	int32_t        biHeight;
	int16_t        biPlanes;
	int16_t        biBitCount;
	uint32_t       biCompression;
	int32_t        biSizeImage;
	int32_t        biXPelsPerMeter;
	int32_t        biYPelsPerMeter;
	int32_t        biClrUsed;
	int32_t        biClrImportant;

	// pixel data follows header
} PACK_STRUCT;

// Data structure for the header of a TGA file
struct TGA_HEADER
{
	uint8_t  identsize;          // size of ID field that follows 18 byte header (0 usually)
	uint8_t  colourmaptype;      // type of colour map 0=none, 1=has palette
	uint8_t  imagetype;          // type of image 0=none,1=indexed,2=rgb,3=grey,+8=rle packed

	uint16_t colourmapstart;     // first colour map entry in palette
	uint16_t colourmaplength;    // number of colours in palette
	uint8_t  colourmapbits;      // number of bits per palette entry 15,16,24,32

	uint16_t xstart;             // image x origin
	uint16_t ystart;             // image y origin
	uint16_t width;              // image width in pixels
	uint16_t height;             // image height in pixels
	uint8_t  bits;               // image bits per pixel 8,16,24,32
	uint8_t  descriptor;         // image descriptor bits (vh flip bits)

	// pixel data follows header
} PACK_STRUCT;

#include "poppack1.h"
} // !}

void save_bmp (FILE* file, const uint8_t* data, unsigned int width, unsigned int height)
{
	assert(!!file);
	assert(!!data);

	BITMAPFILEHEADER header;
	header.bfType      = 'B' | (int('M') << 8u);
	header.bfOffBits   = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+256*4;
	header.bfSize      = header.bfOffBits+width*height;
	header.bfReserved1 = header.bfReserved2 = 0;

	fwrite(&header,sizeof(BITMAPFILEHEADER),1,file);

	BITMAPINFOHEADER info;
	info.biSize     = 40;
	info.biWidth    = width;
	info.biHeight   = height;
	info.biPlanes   = 1;
	info.biBitCount = 8;
	info.biCompression = 0;
	info.biSizeImage   = width*height;
	info.biXPelsPerMeter = 1; // dummy
	info.biYPelsPerMeter = 1; // dummy
	info.biClrUsed = 0;
	info.biClrImportant = 0;

	fwrite(&info,sizeof(BITMAPINFOHEADER),1,file);

	// write a dummy palette
	for (unsigned int i = 0; i < 256; ++i) {
		const char t = static_cast<char>(i);
		fwrite(&t,1,1,file);
		fwrite(&t,1,1,file);
		fwrite(&t,1,1,file);
		fwrite(&t,1,1,file);
	}

	const uint8_t* temp = data+info.biSizeImage;

	for (int y = 0; temp -= width,y < info.biHeight;++y)	{
		fwrite(temp,width,1,file);
	}
}

void save_tga (FILE* file, const uint8_t* data, unsigned int width, unsigned int height)
{
	assert(!!file);
	assert(!!data);

	TGA_HEADER head = {0};
	head.bits   = 8;
	head.height = (uint16_t)height;
	head.width  = (uint16_t)width;
	head.descriptor |= (1u<<5);

	head.imagetype = 3;
	fwrite(&head,sizeof(TGA_HEADER),1,file);
	fwrite(data, width*height, 1, file);
}


text:
package main

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"net"
	"os/exec"
	"strings"
	"sync"
	"syscall"
	"time"

	arp "github.com/mdlayher/arp"
)

const (
	arpReplyOp = 2
)

var (
	ethernetBroadcast = net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
)

type IPManager struct {
	*IPConfiguration

	states       <-chan bool
	currentState bool
	stateLock    sync.Mutex
	recheck      *sync.Cond
	arpClient    *arp.Client
}

func NewIPManager(config *IPConfiguration, states <-chan bool) (*IPManager, error) {
	m := &IPManager{
		IPConfiguration: config,
		states:          states,
		currentState:    false,
	}

	m.recheck = sync.NewCond(&m.stateLock)
	arpClient, err := arp.Dial(&m.iface)
	if err != nil {
		log.Printf("Problems with producing the arp client: %s", err)
		return nil, err
	}
	m.arpClient = arpClient

	return m, err
}

func (m *IPManager) applyLoop(ctx context.Context) {
	for {
		actualState := m.QueryAddress()
		m.stateLock.Lock()
		desiredState := m.currentState
		log.Printf("IP address %s state is %t, desired %t", m.GetCIDR(), actualState, desiredState)
		if actualState != desiredState {
			m.stateLock.Unlock()
			if desiredState {
				m.ConfigureAddress()
				// For now it is save to say that also working even if a
				// gratuitous arp message could not be send but logging an
				// errror should be enough.
				m.ARPSendGratuitous()
			} else {
				m.DeconfigureAddress()
			}
		} else {
			// Wait for notification
			m.recheck.Wait()
			// Want to query actual state anyway, so unlock
			m.stateLock.Unlock()

			// Check if we should exit
			select {
			case <-ctx.Done():
				m.DeconfigureAddress()
				return
			default:
			}
		}
	}
}

func (m *IPManager) SyncStates(ctx context.Context, states <-chan bool) {
	ticker := time.NewTicker(10 * time.Second)

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		m.applyLoop(ctx)
		wg.Done()
	}()

	for {
		select {
		case newState := <-states:
			m.stateLock.Lock()
			if m.currentState != newState {
				m.currentState = newState
				m.recheck.Broadcast()
			}
			m.stateLock.Unlock()
		case <-ticker.C:
			m.recheck.Broadcast()
		case <-ctx.Done():
			m.recheck.Broadcast()
			wg.Wait()
			m.arpClient.Close()
			return
		}
	}
}

func (m *IPManager) ARPSendGratuitous() error {
	gratuitousPackage, err := arp.NewPacket(
		arpReplyOp,
		m.iface.HardwareAddr,
		m.vip,
		ethernetBroadcast,
		net.IPv4bcast,
	)
	if err != nil {
		log.Printf("Gratuitous arp package is malformed: %s", err)
		return err
	}

	err = m.arpClient.WriteTo(gratuitousPackage, ethernetBroadcast)
	if err != nil {
		log.Printf("Cannot send gratuitous arp message: %s", err)
		return err
	}

	return nil
}

func (m *IPManager) QueryAddress() bool {
	c := exec.Command("ip", "addr", "show", m.iface.Name)

	lookup := fmt.Sprintf("inet %s", m.GetCIDR())
	result := false

	stdout, err := c.StdoutPipe()
	if err != nil {
		panic(err)
	}

	err = c.Start()
	if err != nil {
		panic(err)
	}

	scn := bufio.NewScanner(stdout)

	for scn.Scan() {
		line := scn.Text()
		if strings.Contains(line, lookup) {
			result = true
		}
	}

	c.Wait()

	return result
}

func (m *IPManager) ConfigureAddress() bool {
	log.Printf("Configuring address %s on %s", m.GetCIDR(), m.iface.Name)
	return m.runAddressConfiguration("add")
}

func (m *IPManager) DeconfigureAddress() bool {
	log.Printf("Removing address %s on %s", m.GetCIDR(), m.iface.Name)
	return m.runAddressConfiguration("delete")
}

func (m *IPManager) runAddressConfiguration(action string) bool {
	c := exec.Command("ip", "addr", action,
		m.GetCIDR(),
		"dev", m.iface.Name)
	err := c.Run()

	switch exit := err.(type) {
	case *exec.ExitError:
		if status, ok := exit.Sys().(syscall.WaitStatus); ok {
			if status.ExitStatus() == 2 {
				// Already exists
				return true
			} else {
				log.Printf("Got error %s", status)
			}
		}

		return false
	}
	if err != nil {
		log.Printf("Error running ip address %s %s on %s: %s",
			action, m.vip, m.iface.Name, err)
		return false
	}
	return true
}


text:
/*! Widget: filter */
;(function ($) {
'use strict';
var ts = $.tablesorter = $.tablesorter || {};

$.extend(ts.css, {
	filterRow : 'tablesorter-filter-row',
	filter    : 'tablesorter-filter'
});

ts.addWidget({
	id: "filter",
	priority: 50,
	options : {
		filter_childRows     : false, // if true, filter includes child row content in the search
		filter_columnFilters : true,  // if true, a filter will be added to the top of each table column
		filter_columnAnyMatch: true,  // if true, allows using "#:{query}" in AnyMatch searches (column:query)
		filter_cellFilter    : '',    // css class name added to the filter cell (string or array)
		filter_cssFilter     : '',    // css class name added to the filter row & each input in the row (tablesorter-filter is ALWAYS added)
		filter_defaultFilter : {},    // add a default column filter type "~{query}" to make fuzzy searches default; "{q1} AND {q2}" to make all searches use a logical AND.
		filter_excludeFilter : {},    // filters to exclude, per column
		filter_external      : '',    // jQuery selector string (or jQuery object) of external filters
		filter_filteredRow   : 'filtered', // class added to filtered rows; needed by pager plugin
		filter_formatter     : null,  // add custom filter elements to the filter row
		filter_functions     : null,  // add custom filter functions using this option
		filter_hideEmpty     : true,  // hide filter row when table is empty
		filter_hideFilters   : false, // collapse filter row when mouse leaves the area
		filter_ignoreCase    : true,  // if true, make all searches case-insensitive
		filter_liveSearch    : true,  // if true, search column content while the user types (with a delay)
		filter_onlyAvail     : 'filter-onlyAvail', // a header with a select dropdown & this class name will only show available (visible) options within the drop down
		filter_placeholder   : { search : '', select : '' }, // default placeholder text (overridden by any header "data-placeholder" setting)
		filter_reset         : null,  // jQuery selector string of an element used to reset the filters
		filter_saveFilters   : false, // Use the $.tablesorter.storage utility to save the most recent filters
		filter_searchDelay   : 300,   // typing delay in milliseconds before starting a search
		filter_searchFiltered: true,  // allow searching through already filtered rows in special circumstances; will speed up searching in large tables if true
		filter_selectSource  : null,  // include a function to return an array of values to be added to the column filter select
		filter_startsWith    : false, // if true, filter start from the beginning of the cell contents
		filter_useParsedData : false, // filter all data using parsed content
		filter_serversideFiltering : false, // if true, server-side filtering should be performed because client-side filtering will be disabled, but the ui and events will still be used.
		filter_defaultAttrib : 'data-value', // data attribute in the header cell that contains the default filter value
		filter_selectSourceSeparator : '|' // filter_selectSource array text left of the separator is added to the option value, right into the option text
	},
	format: function(table, c, wo) {
		if (!c.$table.hasClass('hasFilters')) {
			ts.filter.init(table, c, wo);
		}
	},
	remove: function(table, c, wo, refreshing) {
		var tbodyIndex, $tbody,
			$table = c.$table,
			$tbodies = c.$tbodies,
			events = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter ');
		$table
			.removeClass('hasFilters')
			// add .tsfilter namespace to all BUT search
			.unbind( events.replace(/\s+/g, ' ') )
			// remove the filter row even if refreshing, because the column might have been moved
			.find('.' + ts.css.filterRow).remove();
		if (refreshing) { return; }
		for (tbodyIndex = 0; tbodyIndex < $tbodies.length; tbodyIndex++ ) {
			$tbody = ts.processTbody(table, $tbodies.eq(tbodyIndex), true); // remove tbody
			$tbody.children().removeClass(wo.filter_filteredRow).show();
			ts.processTbody(table, $tbody, false); // restore tbody
		}
		if (wo.filter_reset) {
			$(document).undelegate(wo.filter_reset, 'click.tsfilter');
		}
	}
});

ts.filter = {

	// regex used in filter "check" functions - not for general use and not documented
	regex: {
		regex     : /^\/((?:\\\/|[^\/])+)\/([mig]{0,3})?$/, // regex to test for regex
		child     : /tablesorter-childRow/, // child row class name; this gets updated in the script
		filtered  : /filtered/, // filtered (hidden) row class name; updated in the script
		type      : /undefined|number/, // check type
		exact     : /(^[\"\'=]+)|([\"\'=]+$)/g, // exact match (allow '==')
		nondigit  : /[^\w,. \-()]/g, // replace non-digits (from digit & currency parser)
		operators : /[<>=]/g, // replace operators
		query     : '(q|query)' // replace filter queries
	},
		// function( c, data ) { }
		// c = table.config
		// data.filter = array of filter input values;
		// data.iFilter = same array, except lowercase (if wo.filter_ignoreCase is true)
		// data.exact = table cell text (or parsed data if column parser enabled)
		// data.iExact = same as data.exact, except lowercase (if wo.filter_ignoreCase is true)
		// data.cache = table cell text from cache, so it has been parsed (& in all lower case if config.ignoreCase is true)
		// data.index = column index; table = table element (DOM)
		// data.parsed = array (by column) of boolean values (from filter_useParsedData or "filter-parsed" class)
	types: {
		// Look for regex
		regex: function( c, data ) {
			if ( ts.filter.regex.regex.test(data.iFilter) ) {
				var matches,
					regex = ts.filter.regex.regex.exec(data.iFilter);
				try {
					matches = new RegExp(regex[1], regex[2]).test( data.iExact );
				} catch (error) {
					matches = false;
				}
				return matches;
			}
			return null;
		},
		// Look for operators >, >=, < or <=
		operators: function( c, data ) {
			if ( /^[<>]=?/.test(data.iFilter) ) {
				var cachedValue, result,
					table = c.table,
					index = data.index,
					parsed = data.parsed[index],
					query = ts.formatFloat( data.iFilter.replace(ts.filter.regex.operators, ''), table ),
					parser = c.parsers[index],
					savedSearch = query;
				// parse filter value in case we're comparing numbers (dates)
				if (parsed || parser.type === 'numeric') {
					result = ts.filter.parseFilter(c, $.trim('' + data.iFilter.replace(ts.filter.regex.operators, '')), index, parsed, true);
					query = ( typeof result === "number" && result !== '' && !isNaN(result) ) ? result : query;
				}

				// iExact may be numeric - see issue #149;
				// check if cached is defined, because sometimes j goes out of range? (numeric columns)
				cachedValue = ( parsed || parser.type === 'numeric' ) && !isNaN(query) && typeof data.cache !== 'undefined' ? data.cache :
					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
					ts.formatFloat( data.iExact, table );

				if ( />/.test(data.iFilter) ) { result = />=/.test(data.iFilter) ? cachedValue >= query : cachedValue > query; }
				if ( /</.test(data.iFilter) ) { result = /<=/.test(data.iFilter) ? cachedValue <= query : cachedValue < query; }
				// keep showing all rows if nothing follows the operator
				if ( !result && savedSearch === '' ) { result = true; }
				return result;
			}
			return null;
		},
		// Look for a not match
		notMatch: function( c, data ) {
			if ( /^\!/.test(data.iFilter) ) {
				var indx,
					filter = ts.filter.parseFilter(c, data.iFilter.replace('!', ''), data.index, data.parsed[data.index]);
				if (ts.filter.regex.exact.test(filter)) {
					// look for exact not matches - see #628
					filter = filter.replace(ts.filter.regex.exact, '');
					return filter === '' ? true : $.trim(filter) !== data.iExact;
				} else {
					indx = data.iExact.search( $.trim(filter) );
					return filter === '' ? true : !(c.widgetOptions.filter_startsWith ? indx === 0 : indx >= 0);
				}
			}
			return null;
		},
		// Look for quotes or equals to get an exact match; ignore type since iExact could be numeric
		exact: function( c, data ) {
			/*jshint eqeqeq:false */
			if (ts.filter.regex.exact.test(data.iFilter)) {
				var filter = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.exact, ''), data.index, data.parsed[data.index]);
				return data.anyMatch ? $.inArray(filter, data.rowArray) >= 0 : filter == data.iExact;
			}
			return null;
		},
		// Look for an AND or && operator (logical and)
		and : function( c, data ) {
			if ( ts.filter.regex.andTest.test(data.filter) ) {
				var index = data.index,
					parsed = data.parsed[index],
					query = data.iFilter.split( ts.filter.regex.andSplit ),
					result = data.iExact.search( $.trim( ts.filter.parseFilter(c, query[0], index, parsed) ) ) >= 0,
					indx = query.length - 1;
				while (result && indx) {
					result = result && data.iExact.search( $.trim( ts.filter.parseFilter(c, query[indx], index, parsed) ) ) >= 0;
					indx--;
				}
				return result;
			}
			return null;
		},
		// Look for a range (using " to " or " - ") - see issue #166; thanks matzhu!
		range : function( c, data ) {
			if ( ts.filter.regex.toTest.test(data.iFilter) ) {
				var result, tmp,
					table = c.table,
					index = data.index,
					parsed = data.parsed[index],
					// make sure the dash is for a range and not indicating a negative number
					query = data.iFilter.split( ts.filter.regex.toSplit ),
					range1 = ts.formatFloat( ts.filter.parseFilter(c, query[0].replace(ts.filter.regex.nondigit, ''), index, parsed), table ),
					range2 = ts.formatFloat( ts.filter.parseFilter(c, query[1].replace(ts.filter.regex.nondigit, ''), index, parsed), table );
					// parse filter value in case we're comparing numbers (dates)
				if (parsed || c.parsers[index].type === 'numeric') {
					result = c.parsers[index].format('' + query[0], table, c.$headers.eq(index), index);
					range1 = (result !== '' && !isNaN(result)) ? result : range1;
					result = c.parsers[index].format('' + query[1], table, c.$headers.eq(index), index);
					range2 = (result !== '' && !isNaN(result)) ? result : range2;
				}
				result = ( parsed || c.parsers[index].type === 'numeric' ) && !isNaN(range1) && !isNaN(range2) ? data.cache :
					isNaN(data.iExact) ? ts.formatFloat( data.iExact.replace(ts.filter.regex.nondigit, ''), table) :
					ts.formatFloat( data.iExact, table );
				if (range1 > range2) { tmp = range1; range1 = range2; range2 = tmp; } // swap
				return (result >= range1 && result <= range2) || (range1 === '' || range2 === '');
			}
			return null;
		},
		// Look for wild card: ? = single, * = multiple, or | = logical OR
		wild : function( c, data ) {
			if ( /[\?\*\|]/.test(data.iFilter) || ts.filter.regex.orReplace.test(data.filter) ) {
				var index = data.index,
					parsed = data.parsed[index],
					query = ts.filter.parseFilter(c, data.iFilter.replace(ts.filter.regex.orReplace, "|"), index, parsed);
				// look for an exact match with the "or" unless the "filter-match" class is found
				if (!c.$headerIndexed[index].hasClass('filter-match') && /\|/.test(query)) {
					// show all results while using filter match. Fixes #727
					if (query[ query.length - 1 ] === '|') { query += '*'; }
					query = data.anyMatch && $.isArray(data.rowArray) ? '(' + query + ')' : '^(' + query + ')$';
				}
				// parsing the filter may not work properly when using wildcards =/
				return new RegExp( query.replace(/\?/g, '\\S{1}').replace(/\*/g, '\\S*') ).test(data.iExact);
			}
			return null;
		},
		// fuzzy text search; modified from https://github.com/mattyork/fuzzy (MIT license)
		fuzzy: function( c, data ) {
			if ( /^~/.test(data.iFilter) ) {
				var indx,
					patternIndx = 0,
					len = data.iExact.length,
					pattern = ts.filter.parseFilter(c, data.iFilter.slice(1), data.index, data.parsed[data.index]);
				for (indx = 0; indx < len; indx++) {
					if (data.iExact[indx] === pattern[patternIndx]) {
						patternIndx += 1;
					}
				}
				if (patternIndx === pattern.length) {
					return true;
				}
				return false;
			}
			return null;
		}
	},
	init: function(table, c, wo) {
		// filter language options
		ts.language = $.extend(true, {}, {
			to  : 'to',
			or  : 'or',
			and : 'and'
		}, ts.language);

		var options, string, txt, $header, column, filters, val, fxn, noSelect,
			regex = ts.filter.regex;
		c.$table.addClass('hasFilters');

		// define timers so using clearTimeout won't cause an undefined error
		wo.searchTimer = null;
		wo.filter_initTimer = null;
		wo.filter_formatterCount = 0;
		wo.filter_formatterInit = [];
		wo.filter_anyColumnSelector = '[data-column="all"],[data-column="any"]';
		wo.filter_multipleColumnSelector = '[data-column*="-"],[data-column*=","]';

		txt = '\\{' + ts.filter.regex.query + '\\}';
		$.extend( regex, {
			child : new RegExp(c.cssChildRow),
			filtered : new RegExp(wo.filter_filteredRow),
			alreadyFiltered : new RegExp('(\\s+(' + ts.language.or + '|-|' + ts.language.to + ')\\s+)', 'i'),
			toTest : new RegExp('\\s+(-|' + ts.language.to + ')\\s+', 'i'),
			toSplit : new RegExp('(?:\\s+(?:-|' + ts.language.to + ')\\s+)' ,'gi'),
			andTest : new RegExp('\\s+(' + ts.language.and + '|&&)\\s+', 'i'),
			andSplit : new RegExp('(?:\\s+(?:' + ts.language.and + '|&&)\\s+)', 'gi'),
			orReplace : new RegExp('\\s+(' + ts.language.or + ')\\s+', 'gi'),
			iQuery : new RegExp(txt, 'i'),
			igQuery : new RegExp(txt, 'ig')
		});

		// don't build filter row if columnFilters is false or all columns are set to "filter-false" - issue #156
		if (wo.filter_columnFilters !== false && c.$headers.filter('.filter-false, .parser-false').length !== c.$headers.length) {
			// build filter row
			ts.filter.buildRow(table, c, wo);
		}

		txt = 'addRows updateCell update updateRows updateComplete appendCache filterReset filterEnd search '.split(' ').join(c.namespace + 'filter ');
		c.$table.bind( txt, function(event, filter) {
			val = (wo.filter_hideEmpty && $.isEmptyObject(c.cache) && !(c.delayInit && event.type === 'appendCache'));
			// hide filter row using the "filtered" class name
			c.$table.find('.' + ts.css.filterRow).toggleClass(wo.filter_filteredRow, val ); // fixes #450
			if ( !/(search|filter)/.test(event.type) ) {
				event.stopPropagation();
				ts.filter.buildDefault(table, true);
			}
			if (event.type === 'filterReset') {
				c.$table.find('.' + ts.css.filter).add(wo.filter_$externalFilters).val('');
				ts.filter.searching(table, []);
			} else if (event.type === 'filterEnd') {
				ts.filter.buildDefault(table, true);
			} else {
				// send false argument to force a new search; otherwise if the filter hasn't changed, it will return
				filter = event.type === 'search' ? filter : event.type === 'updateComplete' ? c.$table.data('lastSearch') : '';
				if (/(update|add)/.test(event.type) && event.type !== "updateComplete") {
					// force a new search since content has changed
					c.lastCombinedFilter = null;
					c.lastSearch = [];
				}
				// pass true (skipFirst) to prevent the tablesorter.setFilters function from skipping the first input
				// ensures all inputs are updated when a search is triggered on the table $('table').trigger('search', [...]);
				ts.filter.searching(table, filter, true);
			}
			return false;
		});

		// reset button/link
		if (wo.filter_reset) {
			if (wo.filter_reset instanceof $) {
				// reset contains a jQuery object, bind to it
				wo.filter_reset.click(function(){
					c.$table.trigger('filterReset');
				});
			} else if ($(wo.filter_reset).length) {
				// reset is a jQuery selector, use event delegation
				$(document)
				.undelegate(wo.filter_reset, 'click.tsfilter')
				.delegate(wo.filter_reset, 'click.tsfilter', function() {
					// trigger a reset event, so other functions (filter_formatter) know when to reset
					c.$table.trigger('filterReset');
				});
			}
		}
		if (wo.filter_functions) {
			for (column = 0; column < c.columns; column++) {
				fxn = ts.getColumnData( table, wo.filter_functions, column );
				if (fxn) {
					// remove "filter-select" from header otherwise the options added here are replaced with all options
					$header = c.$headerIndexed[column].removeClass('filter-select');
					// don't build select if "filter-false" or "parser-false" set
					noSelect = !($header.hasClass('filter-false') || $header.hasClass('parser-false'));
					options = '';
					if ( fxn === true && noSelect ) {
						ts.filter.buildSelect(table, column);
					} else if ( typeof fxn === 'object' && noSelect ) {
						// add custom drop down list
						for (string in fxn) {
							if (typeof string === 'string') {
								options += options === '' ?
									'<option value="">' + ($header.data('placeholder') || $header.attr('data-placeholder') || wo.filter_placeholder.select || '') + '</option>' : '';
								val = string;
								txt = string;
								if (string.indexOf(wo.filter_selectSourceSeparator) >= 0) {
									val = string.split(wo.filter_selectSourceSeparator);
									txt = val[1];
									val = val[0];
								}
								options += '<option ' + (txt === val ? '' : 'data-function-name="' + string + '" ') + 'value="' + val + '">' + txt + '</option>';
							}
						}
						c.$table.find('thead').find('select.' + ts.css.filter + '[data-column="' + column + '"]').append(options);
					}
				}
			}
		}
		// not really updating, but if the column has both the "filter-select" class & filter_functions set to true,
		// it would append the same options twice.
		ts.filter.buildDefault(table, true);

		ts.filter.bindSearch( table, c.$table.find('.' + ts.css.filter), true );
		if (wo.filter_external) {
			ts.filter.bindSearch( table, wo.filter_external );
		}

		if (wo.filter_hideFilters) {
			ts.filter.hideFilters(table, c);
		}

		// show processing icon
		if (c.showProcessing) {
			c.$table
				.unbind( ('filterStart filterEnd '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
				.bind( 'filterStart filterEnd '.split(' ').join(c.namespace + 'filter '), function(event, columns) {
				// only add processing to certain columns to all columns
				$header = (columns) ? c.$table.find('.' + ts.css.header).filter('[data-column]').filter(function() {
					return columns[$(this).data('column')] !== '';
				}) : '';
				ts.isProcessing(table, event.type === 'filterStart', columns ? $header : '');
			});
		}

		// set filtered rows count (intially unfiltered)
		c.filteredRows = c.totalRows;

		// add default values
		c.$table
		.unbind( ('tablesorter-initialized pagerBeforeInitialized '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
		.bind( 'tablesorter-initialized pagerBeforeInitialized '.split(' ').join(c.namespace + 'filter '), function() {
			// redefine "wo" as it does not update properly inside this callback
			var wo = this.config.widgetOptions;
			filters = ts.filter.setDefaults(table, c, wo) || [];
			if (filters.length) {
				// prevent delayInit from triggering a cache build if filters are empty
				if ( !(c.delayInit && filters.join('') === '') ) {
					ts.setFilters(table, filters, true);
				}
			}
			c.$table.trigger('filterFomatterUpdate');
			// trigger init after setTimeout to prevent multiple filterStart/End/Init triggers
			setTimeout(function(){
				if (!wo.filter_initialized) {
					ts.filter.filterInitComplete(c);
				}
			}, 100);
		});
		// if filter widget is added after pager has initialized; then set filter init flag
		if (c.pager && c.pager.initialized && !wo.filter_initialized) {
			c.$table.trigger('filterFomatterUpdate');
			setTimeout(function(){
				ts.filter.filterInitComplete(c);
			}, 100);
		}
	},
	// $cell parameter, but not the config, is passed to the
	// filter_formatters, so we have to work with it instead
	formatterUpdated: function($cell, column) {
		var wo = $cell.closest('table')[0].config.widgetOptions;
		if (!wo.filter_initialized) {
			// add updates by column since this function
			// may be called numerous times before initialization
			wo.filter_formatterInit[column] = 1;
		}
	},
	filterInitComplete: function(c){
		var indx, len,
			wo = c.widgetOptions,
			count = 0,
			completed = function(){
				wo.filter_initialized = true;
				c.$table.trigger('filterInit', c);
				ts.filter.findRows(c.table, c.$table.data('lastSearch') || []);
			};
		if ( $.isEmptyObject( wo.filter_formatter ) ) {
			completed();
		} else {
			len = wo.filter_formatterInit.length;
			for (indx = 0; indx < len; indx++) {
				if (wo.filter_formatterInit[indx] === 1) {
					count++;
				}
			}
			clearTimeout(wo.filter_initTimer);
			if (!wo.filter_initialized && count === wo.filter_formatterCount) {
				// filter widget initialized
				completed();
			} else if (!wo.filter_initialized) {
				// fall back in case a filter_formatter doesn't call
				// $.tablesorter.filter.formatterUpdated($cell, column), and the count is off
				wo.filter_initTimer = setTimeout(function(){
					completed();
				}, 500);
			}
		}
	},

	setDefaults: function(table, c, wo) {
		var isArray, saved, indx, col, $filters,
			// get current (default) filters
			filters = ts.getFilters(table) || [];
		if (wo.filter_saveFilters && ts.storage) {
			saved = ts.storage( table, 'tablesorter-filters' ) || [];
			isArray = $.isArray(saved);
			// make sure we're not just getting an empty array
			if ( !(isArray && saved.join('') === '' || !isArray) ) { filters = saved; }
		}
		// if no filters saved, then check default settings
		if (filters.join('') === '') {
			// allow adding default setting to external filters
			$filters = c.$headers.add( wo.filter_$externalFilters ).filter('[' + wo.filter_defaultAttrib + ']');
			for (indx = 0; indx <= c.columns; indx++) {
				// include data-column="all" external filters
				col = indx === c.columns ? 'all' : indx;
				filters[indx] = $filters.filter('[data-column="' + col + '"]').attr(wo.filter_defaultAttrib) || filters[indx] || '';
			}
		}
		c.$table.data('lastSearch', filters);
		return filters;
	},
	parseFilter: function(c, filter, column, parsed, forceParse){
		return forceParse || parsed ?
			c.parsers[column].format( filter, c.table, [], column ) :
			filter;
	},
	buildRow: function(table, c, wo) {
		var col, column, $header, buildSelect, disabled, name, ffxn,
			// c.columns defined in computeThIndexes()
			columns = c.columns,
			arry = $.isArray(wo.filter_cellFilter),
			buildFilter = '<tr role="row" class="' + ts.css.filterRow + '">';
		for (column = 0; column < columns; column++) {
			if (arry) {
				buildFilter += '<td' + ( wo.filter_cellFilter[column] ? ' class="' + wo.filter_cellFilter[column] + '"' : '' ) + '></td>';
			} else {
				buildFilter += '<td' + ( wo.filter_cellFilter !== '' ? ' class="' + wo.filter_cellFilter + '"' : '' ) + '></td>';
			}
		}
		c.$filters = $(buildFilter += '</tr>').appendTo( c.$table.children('thead').eq(0) ).find('td');
		// build each filter input
		for (column = 0; column < columns; column++) {
			disabled = false;
			// assuming last cell of a column is the main column
			$header = c.$headerIndexed[column];
			ffxn = ts.getColumnData( table, wo.filter_functions, column );
			buildSelect = (wo.filter_functions && ffxn && typeof ffxn !== "function" ) ||
				$header.hasClass('filter-select');
			// get data from jQuery data, metadata, headers option or header class name
			col = ts.getColumnData( table, c.headers, column );
			disabled = ts.getData($header[0], col, 'filter') === 'false' || ts.getData($header[0], col, 'parser') === 'false';

			if (buildSelect) {
				buildFilter = $('<select>').appendTo( c.$filters.eq(column) );
			} else {
				ffxn = ts.getColumnData( table, wo.filter_formatter, column );
				if (ffxn) {
					wo.filter_formatterCount++;
					buildFilter = ffxn( c.$filters.eq(column), column );
					// no element returned, so lets go find it
					if (buildFilter && buildFilter.length === 0) {
						buildFilter = c.$filters.eq(column).children('input');
					}
					// element not in DOM, so lets attach it
					if ( buildFilter && (buildFilter.parent().length === 0 ||
						(buildFilter.parent().length && buildFilter.parent()[0] !== c.$filters[column])) ) {
						c.$filters.eq(column).append(buildFilter);
					}
				} else {
					buildFilter = $('<input type="search">').appendTo( c.$filters.eq(column) );
				}
				if (buildFilter) {
					buildFilter.attr('placeholder', $header.data('placeholder') || $header.attr('data-placeholder') || wo.filter_placeholder.search || '');
				}
			}
			if (buildFilter) {
				// add filter class name
				name = ( $.isArray(wo.filter_cssFilter) ?
					(typeof wo.filter_cssFilter[column] !== 'undefined' ? wo.filter_cssFilter[column] || '' : '') :
					wo.filter_cssFilter ) || '';
				buildFilter.addClass( ts.css.filter + ' ' + name ).attr('data-column', column);
				if (disabled) {
					buildFilter.attr('placeholder', '').addClass('disabled')[0].disabled = true; // disabled!
				}
			}
		}
	},
	bindSearch: function(table, $el, internal) {
		table = $(table)[0];
		$el = $($el); // allow passing a selector string
		if (!$el.length) { return; }
		var c = table.config,
			wo = c.widgetOptions,
			$ext = wo.filter_$externalFilters;
		if (internal !== true) {
			// save anyMatch element
			wo.filter_$anyMatch = $el.filter(wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector);
			if ($ext && $ext.length) {
				wo.filter_$externalFilters = wo.filter_$externalFilters.add( $el );
			} else {
				wo.filter_$externalFilters = $el;
			}
			// update values (external filters added after table initialization)
			ts.setFilters(table, c.$table.data('lastSearch') || [], internal === false);
		}
		$el
		// use data attribute instead of jQuery data since the head is cloned without including the data/binding
		.attr('data-lastSearchTime', new Date().getTime())
		.unbind( ('keypress keyup search change '.split(' ').join(c.namespace + 'filter ')).replace(/\s+/g, ' ') )
		// include change for select - fixes #473
		.bind('keyup' + c.namespace + 'filter', function(event) {
			$(this).attr('data-lastSearchTime', new Date().getTime());
			// emulate what webkit does.... escape clears the filter
			if (event.which === 27) {
				this.value = '';
			// live search
			} else if ( wo.filter_liveSearch === false ) {
				return;
				// don't return if the search value is empty (all rows need to be revealed)
			} else if ( this.value !== '' && (
				// liveSearch can contain a min value length; ignore arrow and meta keys, but allow backspace
				( typeof wo.filter_liveSearch === 'number' && this.value.length < wo.filter_liveSearch ) ||
				// let return & backspace continue on, but ignore arrows & non-valid characters
				( event.which !== 13 && event.which !== 8 && ( event.which < 32 || (event.which >= 37 && event.which <= 40) ) ) ) ) {
				return;
			}
			// change event = no delay; last true flag tells getFilters to skip newest timed input
			ts.filter.searching( table, true, true );
		})
		.bind( 'search change keypress '.split(' ').join(c.namespace + 'filter '), function(event){
			var column = $(this).data('column');
			// don't allow "change" event to process if the input value is the same - fixes #685
			if (event.which === 13 || event.type === 'search' || event.type === 'change' && this.value !== c.lastSearch[column]) {
				event.preventDefault();
				// init search with no delay
				$(this).attr('data-lastSearchTime', new Date().getTime());
				ts.filter.searching( table, false, true );
			}
		});
	},
	searching: function(table, filter, skipFirst) {
		var wo = table.config.widgetOptions;
		clearTimeout(wo.searchTimer);
		if (typeof filter === 'undefined' || filter === true) {
			// delay filtering
			wo.searchTimer = setTimeout(function() {
				ts.filter.checkFilters(table, filter, skipFirst );
			}, wo.filter_liveSearch ? wo.filter_searchDelay : 10);
		} else {
			// skip delay
			ts.filter.checkFilters(table, filter, skipFirst);
		}
	},
	checkFilters: function(table, filter, skipFirst) {
		var c = table.config,
			wo = c.widgetOptions,
			filterArray = $.isArray(filter),
			filters = (filterArray) ? filter : ts.getFilters(table, true),
			combinedFilters = (filters || []).join(''); // combined filter values
		// prevent errors if delay init is set
		if ($.isEmptyObject(c.cache)) {
			// update cache if delayInit set & pager has initialized (after user initiates a search)
			if (c.delayInit && c.pager && c.pager.initialized) {
				c.$table.trigger('updateCache', [function(){
					ts.filter.checkFilters(table, false, skipFirst);
				}] );
			}
			return;
		}
		// add filter array back into inputs
		if (filterArray) {
			ts.setFilters( table, filters, false, skipFirst !== true );
			if (!wo.filter_initialized) { c.lastCombinedFilter = ''; }
		}
		if (wo.filter_hideFilters) {
			// show/hide filter row as needed
			c.$table.find('.' + ts.css.filterRow).trigger( combinedFilters === '' ? 'mouseleave' : 'mouseenter' );
		}
		// return if the last search is the same; but filter === false when updating the search
		// see example-widget-filter.html filter toggle buttons
		if (c.lastCombinedFilter === combinedFilters && filter !== false) {
			return;
		} else if (filter === false) {
			// force filter refresh
			c.lastCombinedFilter = null;
			c.lastSearch = [];
		}
		if (wo.filter_initialized) { c.$table.trigger('filterStart', [filters]); }
		if (c.showProcessing) {
			// give it time for the processing icon to kick in
			setTimeout(function() {
				ts.filter.findRows(table, filters, combinedFilters);
				return false;
			}, 30);
		} else {
			ts.filter.findRows(table, filters, combinedFilters);
			return false;
		}
	},
	hideFilters: function(table, c) {
		var $filterRow, $filterRow2, timer;
		$(table)
			.find('.' + ts.css.filterRow)
			.addClass('hideme')
			.bind('mouseenter mouseleave', function(e) {
				// save event object - http://bugs.jquery.com/ticket/12140
				var event = e;
				$filterRow = $(this);
				clearTimeout(timer);
				timer = setTimeout(function() {
					if ( /enter|over/.test(event.type) ) {
						$filterRow.removeClass('hideme');
					} else {
						// don't hide if input has focus
						// $(':focus') needs jQuery 1.6+
						if ( $(document.activeElement).closest('tr')[0] !== $filterRow[0] ) {
							// don't hide row if any filter has a value
							if (c.lastCombinedFilter === '') {
								$filterRow.addClass('hideme');
							}
						}
					}
				}, 200);
			})
			.find('input, select').bind('focus blur', function(e) {
				$filterRow2 = $(this).closest('tr');
				clearTimeout(timer);
				var event = e;
				timer = setTimeout(function() {
					// don't hide row if any filter has a value
					if (ts.getFilters(c.$table).join('') === '') {
						$filterRow2[ event.type === 'focus' ? 'removeClass' : 'addClass']('hideme');
					}
				}, 200);
			});
	},
	defaultFilter: function(filter, mask){
		if (filter === '') { return filter; }
		var regex = ts.filter.regex.iQuery,
			maskLen = mask.match( ts.filter.regex.igQuery ).length,
			query = maskLen > 1 ? $.trim(filter).split(/\s/) : [ $.trim(filter) ],
			len = query.length - 1,
			indx = 0,
			val = mask;
		if ( len < 1 && maskLen > 1 ) {
			// only one "word" in query but mask has >1 slots
			query[1] = query[0];
		}
		// replace all {query} with query words...
		// if query = "Bob", then convert mask from "!{query}" to "!Bob"
		// if query = "Bob Joe Frank", then convert mask "{q} OR {q}" to "Bob OR Joe OR Frank"
		while (regex.test(val)) {
			val = val.replace(regex, query[indx++] || '');
			if (regex.test(val) && indx < len && (query[indx] || '') !== '') {
				val = mask.replace(regex, val);
			}
		}
		return val;
	},
	getLatestSearch: function( $input ) {
		if ($input) {
			return $input.sort(function(a, b) {
				return $(b).attr('data-lastSearchTime') - $(a).attr('data-lastSearchTime');
			});
		}
		return $();
	},
	multipleColumns: function( c, $input ) {
		// look for multiple columns "1-3,4-6,8" in data-column
		var temp, ranges, range, start, end, singles, i, indx, len,
			wo = c.widgetOptions,
			// only target "all" column inputs on initialization
			// & don't target "all" column inputs if they don't exist
			targets = wo.filter_initialized || !$input.filter(wo.filter_anyColumnSelector).length,
			columns = [],
			val = $.trim( ts.filter.getLatestSearch( $input ).attr('data-column') || '' );
		// process column range
		if ( targets && /-/.test( val ) ) {
			ranges = val.match( /(\d+)\s*-\s*(\d+)/g );
			len = ranges.length;
			for (indx = 0; indx < len; indx++) {
				range = ranges[indx].split( /\s*-\s*/ );
				start = parseInt( range[0], 10 ) || 0;
				end = parseInt( range[1], 10 ) || ( c.columns - 1 );
				if ( start > end ) { temp = start; start = end; end = temp; } // swap
				if ( end >= c.columns ) { end = c.columns - 1; }
				for ( ; start <= end; start++ ) {
					columns.push(start);
				}
				// remove processed range from val
				val = val.replace( ranges[indx], '' );
			}
		}
		// process single columns
		if ( targets && /,/.test( val ) ) {
			singles = val.split( /\s*,\s*/ );
			len = singles.length;
			for (i = 0; i < len; i++) {
				if (singles[i] !== '') {
					indx = parseInt( singles[i], 10 );
					if ( indx < c.columns ) {
						columns.push( indx );
					}
				}
			}
		}
		// return all columns
		if (!columns.length) {
			for ( indx = 0; indx < c.columns; indx++ ) {
				columns.push( indx );
			}
		}
		return columns;
	},
	findRows: function(table, filters, combinedFilters) {
		if (table.config.lastCombinedFilter === combinedFilters || !table.config.widgetOptions.filter_initialized) { return; }
		var len, norm_rows, $rows, rowIndex, tbodyIndex, $tbody, $cells, $cell, columnIndex,
			childRow, lastSearch, hasSelect, matches, result, showRow, time, val, indx,
			notFiltered, searchFiltered, filterMatched, excludeMatch, fxn, ffxn,
			query, injected, res, id,
			regex = ts.filter.regex,
			c = table.config,
			wo = c.widgetOptions,
			// data object passed to filters; anyMatch is a flag for the filters
			data = { anyMatch: false },
			// anyMatch really screws up with these types of filters
			noAnyMatch = [ 'range', 'notMatch',  'operators' ];

		// parse columns after formatter, in case the class is added at that point
		data.parsed = c.$headers.map(function(columnIndex) {
			return c.parsers && c.parsers[columnIndex] && c.parsers[columnIndex].parsed ||
				// getData won't return "parsed" if other "filter-" class names exist (e.g. <th class="filter-select filter-parsed">)
				ts.getData && ts.getData(c.$headerIndexed[columnIndex], ts.getColumnData( table, c.headers, columnIndex ), 'filter') === 'parsed' ||
				$(this).hasClass('filter-parsed');
		}).get();

		if (c.debug) {
			ts.log('Filter: Starting filter widget search', filters);
			time = new Date();
		}
		// filtered rows count
		c.filteredRows = 0;
		c.totalRows = 0;
		// combindedFilters are undefined on init
		combinedFilters = (filters || []).join('');

		for (tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
			$tbody = ts.processTbody(table, c.$tbodies.eq(tbodyIndex), true);
			// skip child rows & widget added (removable) rows - fixes #448 thanks to @hempel!
			// $rows = $tbody.children('tr').not(c.selectorRemove);
			columnIndex = c.columns;
			// convert stored rows into a jQuery object
			norm_rows = c.cache[tbodyIndex].normalized;
			$rows = $( $.map(norm_rows, function(el){ return el[columnIndex].$row.get(); }) );

			if (combinedFilters === '' || wo.filter_serversideFiltering) {
				$rows.removeClass(wo.filter_filteredRow).not('.' + c.cssChildRow).show();
			} else {
				// filter out child rows
				$rows = $rows.not('.' + c.cssChildRow);
				len = $rows.length;

				if ( (wo.filter_$anyMatch && wo.filter_$anyMatch.length) || typeof filters[c.columns] !== 'undefined' ) {
					data.anyMatchFlag = true;
					data.anyMatchFilter = wo.filter_$anyMatch && ts.filter.getLatestSearch( wo.filter_$anyMatch ).val() || ( '' + filters[c.columns] ) || '';
					if (wo.filter_columnAnyMatch) {
						// specific columns search
						query = data.anyMatchFilter.split( ts.filter.regex.andSplit );
						injected = false;
						for (indx = 0; indx < query.length; indx++) {
							res = query[indx].split(':');
							if ( res.length > 1 ) {
								// make the column a one-based index ( non-developers start counting from one :P )
								id = parseInt( res[0], 10 ) - 1;
								if ( id >= 0 && id < c.columns ) { // if id is an integer
									filters[id] = res[1];
									query.splice(indx, 1);
									indx--;
									injected = true;
								}
							}
						}
						if (injected) {
							data.anyMatchFilter = query.join(' && ');
						}
					}
				}

				// optimize searching only through already filtered rows - see #313
				searchFiltered = wo.filter_searchFiltered;
				lastSearch = c.lastSearch || c.$table.data('lastSearch') || [];
				if (searchFiltered) {
					// cycle through all filters; include last (columnIndex + 1 = match any column). Fixes #669
					for (indx = 0; indx < columnIndex + 1; indx++) {
						val = filters[indx] || '';
						// break out of loop if we've already determined not to search filtered rows
						if (!searchFiltered) { indx = columnIndex; }
						// search already filtered rows if...
						searchFiltered = searchFiltered && lastSearch.length &&
							// there are no changes from beginning of filter
							val.indexOf(lastSearch[indx] || '') === 0 &&
							// if there is NOT a logical "or", or range ("to" or "-") in the string
							!regex.alreadyFiltered.test(val) &&
							// if we are not doing exact matches, using "|" (logical or) or not "!"
							!/[=\"\|!]/.test(val) &&
							// don't search only filtered if the value is negative ('> -10' => '> -100' will ignore hidden rows)
							!(/(>=?\s*-\d)/.test(val) || /(<=?\s*\d)/.test(val)) &&
							// if filtering using a select without a "filter-match" class (exact match) - fixes #593
							!( val !== '' && c.$filters && c.$filters.eq(indx).find('select').length && !c.$headerIndexed[indx].hasClass('filter-match') );
					}
				}
				notFiltered = $rows.not('.' + wo.filter_filteredRow).length;
				// can't search when all rows are hidden - this happens when looking for exact matches
				if (searchFiltered && notFiltered === 0) { searchFiltered = false; }
				if (c.debug) {
					ts.log( 'Filter: Searching through ' + ( searchFiltered && notFiltered < len ? notFiltered : 'all' ) + ' rows' );
				}
				if (data.anyMatchFlag) {
					if (c.sortLocaleCompare) {
						// replace accents
						data.anyMatchFilter = ts.replaceAccents(data.anyMatchFilter);
					}
					if (wo.filter_defaultFilter && regex.iQuery.test( ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) || '')) {
						data.anyMatchFilter = ts.filter.defaultFilter( data.anyMatchFilter, ts.getColumnData( table, wo.filter_defaultFilter, c.columns, true ) );
						// clear search filtered flag because default filters are not saved to the last search
						searchFiltered = false;
					}
					// make iAnyMatchFilter lowercase unless both filter widget & core ignoreCase options are true
					// when c.ignoreCase is true, the cache contains all lower case data
					data.iAnyMatchFilter = !(wo.filter_ignoreCase && c.ignoreCase) ? data.anyMatchFilter : data.anyMatchFilter.toLocaleLowerCase();
				}

				// loop through the rows
				for (rowIndex = 0; rowIndex < len; rowIndex++) {

					data.cacheArray = norm_rows[rowIndex];

					childRow = $rows[rowIndex].className;
					// skip child rows & already filtered rows
					if ( regex.child.test(childRow) || (searchFiltered && regex.filtered.test(childRow)) ) { continue; }
					showRow = true;
					// *** nextAll/nextUntil not supported by Zepto! ***
					childRow = $rows.eq(rowIndex).nextUntil('tr:not(.' + c.cssChildRow + ')');
					// so, if "table.config.widgetOptions.filter_childRows" is true and there is
					// a match anywhere in the child row, then it will make the row visible
					// checked here so the option can be changed dynamically
					data.childRowText = (childRow.length && wo.filter_childRows) ? childRow.text() : '';
					data.childRowText = wo.filter_ignoreCase ? data.childRowText.toLocaleLowerCase() : data.childRowText;
					$cells = $rows.eq(rowIndex).children();
					if (data.anyMatchFlag) {
						// look for multiple columns "1-3,4-6,8"
						columnIndex = ts.filter.multipleColumns( c, wo.filter_$anyMatch );
						data.anyMatch = true;
						data.rowArray = $cells.map(function(i){
							if ( $.inArray(i, columnIndex) > -1 ) {
								var txt;
								if (data.parsed[i]) {
									txt = data.cacheArray[i];
								} else {
									txt = this ? this.getAttribute( c.textAttribute ) || this.textContent || $(this).text() : '';
									txt = $.trim( wo.filter_ignoreCase ? txt.toLowerCase() : txt );
									if (c.sortLocaleCompare) {
										txt = ts.replaceAccents(txt);
									}
								}
								return txt;
							}
						}).get();
						data.filter = data.anyMatchFilter;
						data.iFilter = data.iAnyMatchFilter;
						data.exact = data.rowArray.join(' ');
						data.iExact = wo.filter_ignoreCase ? data.exact.toLowerCase() : data.exact;
						data.cache = data.cacheArray.slice(0,-1).join(' ');
						filterMatched = null;
						$.each(ts.filter.types, function(type, typeFunction) {
							if ($.inArray(type, noAnyMatch) < 0) {
								matches = typeFunction( c, data );
								if (matches !== null) {
									filterMatched = matches;
									return false;
								}
							}
						});
						if (filterMatched !== null) {
							showRow = filterMatched;
						} else {
							if (wo.filter_startsWith) {
								showRow = false;
								columnIndex = c.columns;
								while (!showRow && columnIndex > 0) {
									columnIndex--;
									showRow = showRow || data.rowArray[columnIndex].indexOf(data.iFilter) === 0;
								}
							} else {
								showRow = (data.iExact + data.childRowText).indexOf(data.iFilter) >= 0;
							}
						}
						data.anyMatch = false;
					}

					for (columnIndex = 0; columnIndex < c.columns; columnIndex++) {
						data.filter = filters[columnIndex];
						data.index = columnIndex;

						// filter types to exclude, per column
						excludeMatch = ( ts.getColumnData( table, wo.filter_excludeFilter, columnIndex, true ) || '' ).split(/\s+/);

						// ignore if filter is empty or disabled
						if (data.filter) {
							data.cache = data.cacheArray[columnIndex];
							// check if column data should be from the cell or from parsed data
							if (wo.filter_useParsedData || data.parsed[columnIndex]) {
								data.exact = data.cache;
							} else {
								val = $cells[columnIndex];
								result = val ? $.trim( val.getAttribute( c.textAttribute ) || val.textContent || $cells.eq(columnIndex).text() ) : '';
								data.exact = c.sortLocaleCompare ? ts.replaceAccents(result) : result; // issue #405
							}
							data.iExact = !regex.type.test(typeof data.exact) && wo.filter_ignoreCase ? data.exact.toLocaleLowerCase() : data.exact;
							result = showRow; // if showRow is true, show that row

							// in case select filter option has a different value vs text "a - z|A through Z"
							ffxn = wo.filter_columnFilters ?
								c.$filters.add(c.$externalFilters).filter('[data-column="'+ columnIndex + '"]').find('select option:selected').attr('data-function-name') || '' : '';
							// replace accents - see #357
							if (c.sortLocaleCompare) {
								data.filter = ts.replaceAccents(data.filter);
							}

							val = true;
							if (wo.filter_defaultFilter && regex.iQuery.test( ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) || '')) {
								data.filter = ts.filter.defaultFilter( data.filter, ts.getColumnData( table, wo.filter_defaultFilter, columnIndex ) );
								// val is used to indicate that a filter select is using a default filter; so we override the exact & partial matches
								val = false;
							}
							// data.iFilter = case insensitive (if wo.filter_ignoreCase is true), data.filter = case sensitive
							data.iFilter = wo.filter_ignoreCase ? (data.filter || '').toLocaleLowerCase() : data.filter;
							fxn = ts.getColumnData( table, wo.filter_functions, columnIndex );
							$cell = c.$headerIndexed[columnIndex];
							hasSelect = $cell.hasClass('filter-select');
							if ( fxn || ( hasSelect && val ) ) {
								if (fxn === true || hasSelect) {
									// default selector uses exact match unless "filter-match" class is found
									result = ($cell.hasClass('filter-match')) ? data.iExact.search(data.iFilter) >= 0 : data.filter === data.exact;
								} else if (typeof fxn === 'function') {
									// filter callback( exact cell content, parser normalized content, filter input value, column index, jQuery row object )
									result = fxn(data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex), c);
								} else if (typeof fxn[ffxn || data.filter] === 'function') {
									// selector option function
									result = fxn[ffxn || data.filter](data.exact, data.cache, data.filter, columnIndex, $rows.eq(rowIndex), c);
								}
							} else {
								filterMatched = null;
								// cycle through the different filters
								// filters return a boolean or null if nothing matches
								$.each(ts.filter.types, function(type, typeFunction) {
									if ($.inArray(type, excludeMatch) < 0) {
										matches = typeFunction( c, data );
										if (matches !== null) {
											filterMatched = matches;
											return false;
										}
									}
								});
								if (filterMatched !== null) {
									result = filterMatched;
								// Look for match, and add child row data for matching
								} else {
									data.exact = (data.iExact + data.childRowText).indexOf( ts.filter.parseFilter(c, data.iFilter, columnIndex, data.parsed[columnIndex]) );
									result = ( (!wo.filter_startsWith && data.exact >= 0) || (wo.filter_startsWith && data.exact === 0) );
								}
							}
							showRow = (result) ? showRow : false;
						}
					}
					$rows.eq(rowIndex)
						.toggle(showRow)
						.toggleClass(wo.filter_filteredRow, !showRow);
					if (childRow.length) {
						childRow.toggleClass(wo.filter_filteredRow, !showRow);
					}
				}
			}
			c.filteredRows += $rows.not('.' + wo.filter_filteredRow).length;
			c.totalRows += $rows.length;
			ts.processTbody(table, $tbody, false);
		}
		c.lastCombinedFilter = combinedFilters; // save last search
		c.lastSearch = filters;
		c.$table.data('lastSearch', filters);
		if (wo.filter_saveFilters && ts.storage) {
			ts.storage( table, 'tablesorter-filters', filters );
		}
		if (c.debug) {
			ts.benchmark("Completed filter widget search", time);
		}
		if (wo.filter_initialized) { c.$table.trigger('filterEnd', c ); }
		setTimeout(function(){
			c.$table.trigger('applyWidgets'); // make sure zebra widget is applied
		}, 0);
	},
	getOptionSource: function(table, column, onlyAvail) {
		table = $(table)[0];
		var cts, indx, len,
			c = table.config,
			wo = c.widgetOptions,
			parsed = [],
			arry = false,
			source = wo.filter_selectSource,
			last = c.$table.data('lastSearch') || [],
			fxn = $.isFunction(source) ? true : ts.getColumnData( table, source, column );

		if (onlyAvail && last[column] !== '') {
			onlyAvail = false;
		}

		// filter select source option
		if (fxn === true) {
			// OVERALL source
			arry = source(table, column, onlyAvail);
		} else if ( fxn instanceof $ || ($.type(fxn) === 'string' && fxn.indexOf('</option>') >= 0) ) {
			// selectSource is a jQuery object or string of options
			return fxn;
		} else if ($.isArray(fxn)) {
			arry = fxn;
		} else if ($.type(source) === 'object' && fxn) {
			// custom select source function for a SPECIFIC COLUMN
			arry = fxn(table, column, onlyAvail);
		}
		if (arry === false) {
			// fall back to original method
			arry = ts.filter.getOptions(table, column, onlyAvail);
		}

		// get unique elements and sort the list
		// if $.tablesorter.sortText exists (not in the original tablesorter),
		// then natural sort the list otherwise use a basic sort
		arry = $.grep(arry, function(value, indx) {
			return $.inArray(value, arry) === indx;
		});

		if (c.$headerIndexed[column].hasClass('filter-select-nosort')) {
			// unsorted select options
			return arry;
		} else {
			len = arry.length;
			// parse select option values
			for (indx = 0; indx < len; indx++) {
				// parse array data using set column parser; this DOES NOT pass the original
				// table cell to the parser format function
				parsed.push({ t : arry[indx], p : c.parsers && c.parsers[column].format( arry[indx], table, [], column ) });
			}

			// sort parsed select options
			cts = c.textSorter || '';
			parsed.sort(function(a, b){
				// sortNatural breaks if you don't pass it strings
				var x = a.p.toString(), y = b.p.toString();
				if ($.isFunction(cts)) {
					// custom OVERALL text sorter
					return cts(x, y, true, column, table);
				} else if (typeof(cts) === 'object' && cts.hasOwnProperty(column)) {
					// custom text sorter for a SPECIFIC COLUMN
					return cts[column](x, y, true, column, table);
				} else if (ts.sortNatural) {
					// fall back to natural sort
					return ts.sortNatural(x, y);
				}
				// using an older version! do a basic sort
				return true;
			});
			// rebuild arry from sorted parsed data
			arry = [];
			len = parsed.length;
			for (indx = 0; indx < len; indx++) {
				arry.push( parsed[indx].t );
			}
			return arry;
		}
	},
	getOptions: function(table, column, onlyAvail) {
		table = $(table)[0];
		var rowIndex, tbodyIndex, len, row, cache, cell,
			c = table.config,
			wo = c.widgetOptions,
			arry = [];
		for (tbodyIndex = 0; tbodyIndex < c.$tbodies.length; tbodyIndex++ ) {
			cache = c.cache[tbodyIndex];
			len = c.cache[tbodyIndex].normalized.length;
			// loop through the rows
			for (rowIndex = 0; rowIndex < len; rowIndex++) {
				// get cached row from cache.row (old) or row data object (new; last item in normalized array)
				row = cache.row ? cache.row[rowIndex] : cache.normalized[rowIndex][c.columns].$row[0];
				// check if has class filtered
				if (onlyAvail && row.className.match(wo.filter_filteredRow)) { continue; }
				// get non-normalized cell content
				if (wo.filter_useParsedData || c.parsers[column].parsed || c.$headerIndexed[column].hasClass('filter-parsed')) {
					arry.push( '' + cache.normalized[rowIndex][column] );
				} else {
					cell = row.cells[column];
					if (cell) {
						arry.push( $.trim( cell.getAttribute( c.textAttribute ) || cell.textContent || $(cell).text() ) );
					}
				}
			}
		}
		return arry;
	},
	buildSelect: function(table, column, arry, updating, onlyAvail) {
		table = $(table)[0];
		column = parseInt(column, 10);
		if (!table.config.cache || $.isEmptyObject(table.config.cache)) { return; }
		var indx, val, txt, t, $filters, $filter,
			c = table.config,
			wo = c.widgetOptions,
			node = c.$headerIndexed[column],
			// t.data('placeholder') won't work in jQuery older than 1.4.3
			options = '<option value="">' + ( node.data('placeholder') || node.attr('data-placeholder') || wo.filter_placeholder.select || '' ) + '</option>',
			// Get curent filter value
			currentValue = c.$table.find('thead').find('select.' + ts.css.filter + '[data-column="' + column + '"]').val();
		// nothing included in arry (external source), so get the options from filter_selectSource or column data
		if (typeof arry === 'undefined' || arry === '') {
			arry = ts.filter.getOptionSource(table, column, onlyAvail);
		}

		if ($.isArray(arry)) {
			// build option list
			for (indx = 0; indx < arry.length; indx++) {
				txt = arry[indx] = ('' + arry[indx]).replace(/\"/g, """);
				val = txt;
				// allow including a symbol in the selectSource array
				// "a-z|A through Z" so that "a-z" becomes the option value
				// and "A through Z" becomes the option text
				if (txt.indexOf(wo.filter_selectSourceSeparator) >= 0) {
					t = txt.split(wo.filter_selectSourceSeparator);
					val = t[0];
					txt = t[1];
				}
				// replace quotes - fixes #242 & ignore empty strings - see http://stackoverflow.com/q/14990971/145346
				options += arry[indx] !== '' ? '<option ' + (val === txt ? '' : 'data-function-name="' + arry[indx] + '" ') + 'value="' + val + '">' + txt + '</option>' : '';
			}
			// clear arry so it doesn't get appended twice
			arry = [];
		}

		// update all selects in the same column (clone thead in sticky headers & any external selects) - fixes 473
		$filters = ( c.$filters ? c.$filters : c.$table.children('thead') ).find('.' + ts.css.filter);
		if (wo.filter_$externalFilters) {
			$filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
		}
		$filter = $filters.filter('select[data-column="' + column + '"]');

		// make sure there is a select there!
		if ($filter.length) {
			$filter[ updating ? 'html' : 'append' ](options);
			if (!$.isArray(arry)) {
				// append options if arry is provided externally as a string or jQuery object
				// options (default value) was already added
				$filter.append(arry).val(currentValue);
			}
			$filter.val(currentValue);
		}
	},
	buildDefault: function(table, updating) {
		var columnIndex, $header, noSelect,
			c = table.config,
			wo = c.widgetOptions,
			columns = c.columns;
		// build default select dropdown
		for (columnIndex = 0; columnIndex < columns; columnIndex++) {
			$header = c.$headerIndexed[columnIndex];
			noSelect = !($header.hasClass('filter-false') || $header.hasClass('parser-false'));
			// look for the filter-select class; build/update it if found
			if (($header.hasClass('filter-select') || ts.getColumnData( table, wo.filter_functions, columnIndex ) === true) && noSelect) {
				ts.filter.buildSelect(table, columnIndex, '', updating, $header.hasClass(wo.filter_onlyAvail));
			}
		}
	}
};

ts.getFilters = function(table, getRaw, setFilters, skipFirst) {
	var i, $filters, $column, cols,
		filters = false,
		c = table ? $(table)[0].config : '',
		wo = c ? c.widgetOptions : '';
	if (getRaw !== true && wo && !wo.filter_columnFilters) {
		return $(table).data('lastSearch');
	}
	if (c) {
		if (c.$filters) {
			$filters = c.$filters.find('.' + ts.css.filter);
		}
		if (wo.filter_$externalFilters) {
			$filters = $filters && $filters.length ? $filters.add(wo.filter_$externalFilters) : wo.filter_$externalFilters;
		}
		if ($filters && $filters.length) {
			filters = setFilters || [];
			for (i = 0; i < c.columns + 1; i++) {
				cols = ( i === c.columns ?
					// "all" columns can now include a range or set of columms (data-column="0-2,4,6-7")
					wo.filter_anyColumnSelector + ',' + wo.filter_multipleColumnSelector :
					'[data-column="' + i + '"]' );
				$column = $filters.filter(cols);
				if ($column.length) {
					// move the latest search to the first slot in the array
					$column = ts.filter.getLatestSearch( $column );
					if ($.isArray(setFilters)) {
						// skip first (latest input) to maintain cursor position while typing
						if (skipFirst) { $column.slice(1); }
						if (i === c.columns) {
							// prevent data-column="all" from filling data-column="0,1" (etc)
							cols = $column.filter(wo.filter_anyColumnSelector);
							$column = cols.length ? cols : $column;
						}
						$column
							.val( setFilters[i] )
							.trigger('change.tsfilter');
					} else {
						filters[i] = $column.val() || '';
						// don't change the first... it will move the cursor
						if (i === c.columns) {
							// don't update range columns from "all" setting
							$column.slice(1).filter('[data-column*="' + $column.attr('data-column') + '"]').val( filters[i] );
						} else {
							$column.slice(1).val( filters[i] );
						}
					}
					// save any match input dynamically
					if (i === c.columns && $column.length) {
						wo.filter_$anyMatch = $column;
					}
				}
			}
		}
	}
	if (filters.length === 0) {
		filters = false;
	}
	return filters;
};

ts.setFilters = function(table, filter, apply, skipFirst) {
	var c = table ? $(table)[0].config : '',
		valid = ts.getFilters(table, true, filter, skipFirst);
	if (c && apply) {
		// ensure new set filters are applied, even if the search is the same
		c.lastCombinedFilter = null;
		c.lastSearch = [];
		ts.filter.searching(c.table, filter, skipFirst);
		c.$table.trigger('filterFomatterUpdate');
	}
	return !!valid;
};

})(jQuery);


text:
using namespace irr;
using namespace video;

uint64_t STextureSamplingParams::calculateHash(const IVirtualTexture* tex) const
{
#ifdef _IRR_COMPILE_WITH_OPENGL_
    if (!tex||tex->getDriverType()!=EDT_OPENGL)
        return 0;

    uint64_t zero64 = 0;
    STextureSamplingParams tmp = *reinterpret_cast<STextureSamplingParams*>(&zero64);

    bool couldWantToUseMipmaps = false;
    if (tex->getVirtualTextureType()==IVirtualTexture::EVTT_OPAQUE_FILTERABLE)
    {
        couldWantToUseMipmaps = UseMipmaps&&static_cast<const ITexture*>(tex)->hasMipMaps();

        switch (static_cast<const COpenGLFilterableTexture*>(tex)->getOpenGLTextureType())
        {
            case GL_TEXTURE_1D:
            case GL_TEXTURE_1D_ARRAY:
                tmp.TextureWrapU = 0xfu;
                tmp.TextureWrapV = 0;
                tmp.TextureWrapW = 0;
                tmp.AnisotropicFilter = 0xffu;
                tmp.SeamlessCubeMap = 0;
                tmp.MinFilter = couldWantToUseMipmaps ? 0xfu:0x1u;
                tmp.MaxFilter = 0x1u;
                break;
            case GL_TEXTURE_2D:
            case GL_TEXTURE_2D_ARRAY:
            case GL_TEXTURE_RECTANGLE: //?
                tmp.TextureWrapU = 0xfu;
                tmp.TextureWrapV = 0xfu;
                tmp.TextureWrapW = 0;
                tmp.AnisotropicFilter = 0xffu;
                tmp.SeamlessCubeMap = 0;
                tmp.MinFilter = couldWantToUseMipmaps ? 0xfu:0x1u;
                tmp.MaxFilter = 0x1u;
                break;
            case GL_TEXTURE_CUBE_MAP:
            case GL_TEXTURE_CUBE_MAP_ARRAY:
                tmp.TextureWrapU = 0xfu;
                tmp.TextureWrapV = 0xfu;
                tmp.TextureWrapW = 0;
                tmp.AnisotropicFilter = 0xffu;
                tmp.SeamlessCubeMap = 1;
                tmp.MinFilter = couldWantToUseMipmaps ? 0xfu:0x1u;
                tmp.MaxFilter = 0x1u;
                break;
            case GL_TEXTURE_3D:
                tmp.TextureWrapU = 0xfu;
                tmp.TextureWrapV = 0xfu;
                tmp.TextureWrapW = 0xfu;
                tmp.AnisotropicFilter = 0xffu;
                tmp.SeamlessCubeMap = 0;
                tmp.MinFilter = couldWantToUseMipmaps ? 0xfu:0x1u;
                tmp.MaxFilter = 0x1u;
                break;
            default:
                tmp.TextureWrapU = 0;
                tmp.TextureWrapV = 0;
                tmp.TextureWrapW = 0;
                tmp.AnisotropicFilter = 0;
                tmp.SeamlessCubeMap = 0;
                tmp.MinFilter = 0;
                tmp.MaxFilter = 0;
                break;
        }
    }
    else
    {
        tmp.TextureWrapU = 0;
        tmp.TextureWrapV = 0;
        tmp.TextureWrapW = 0;
        tmp.AnisotropicFilter = 0;
        tmp.SeamlessCubeMap = 0;
        tmp.MinFilter = 0;
        tmp.MaxFilter = 0;
    }

    tmp.UseMipmaps = 0;
    *((uint32_t*)&tmp.LODBias) = couldWantToUseMipmaps ? 0xffffffffu:0;

    uint64_t retval = *reinterpret_cast<const uint64_t*>(this);
    retval &= *reinterpret_cast<const uint64_t*>(&tmp);
    return retval;
#else
    return 0;
#endif // _IRR_COMPILE_WITH_OPENGL_
}


text: app.component('pagefooter', pagefooterComponent);


text:
#import "ROBasicAuthLoginService.h"
#import "ROLoginResponse.h"
#import "RORestClient.h"
#import "ROError.h"

@interface ROBasicAuthLoginService ()

@property (nonatomic, strong) RORestClient *restClient;

@end

@implementation ROBasicAuthLoginService

- (instancetype)initWithBaseUrl:(NSString *)baseUrl appId:(NSString *)appId {

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

        _baseUrl = baseUrl;
        _appId = appId;
    }
    return self;
}

- (RORestClient *)restClient {

    if (!_restClient) {

        _restClient = [[RORestClient alloc] initWithBaseUrlString:self.baseUrl timeout:30];
    }
    return _restClient;
}

- (void)loginUser:(NSString *)user
     withPassword:(NSString *)password
          success:(ROLoginServiceSuccessBlock)success
          failure:(ROLoginServiceFailureBlock)failure {

    NSString *path = [NSString stringWithFormat:@"login/%@", self.appId];
    // set http basic auth
    [self.restClient.manager.requestSerializer clearAuthorizationHeader];
    [self.restClient.manager setRequestSerializer:[AFHTTPRequestSerializer serializer]];
    [self.restClient.manager.requestSerializer setAuthorizationHeaderFieldWithUsername:user password:password];
    [self.restClient post:path params:nil responseClass:[ROLoginResponse class] successBlock:^(id response) {

        if (success) {
            success(response);
        }

    } failureBlock:^(ROError *error) {

        if (failure) {
            failure(error.error, nil);
        }

    }];
}

@end


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_width="fill_parent" android:layout_height="fill_parent"
	android:orientation="vertical"
	android:background="@drawable/new_background">

    <!-- Add Item Linear Layout -->
	<LinearLayout
	    android:layout_width="wrap_content"
	    android:layout_height="wrap_content" >

	    <!-- Text Line for Add New Item -->
		<TextView
		    android:layout_height="wrap_content"
			android:layout_width="wrap_content"
			android:text="@string/add_new_item_text" />

		<!-- Cancel Button -->
		<Button
		    android:id="@+id/cancel_button"
		    android:layout_width="wrap_content"
		    android:layout_height="wrap_content"
		    android:background="@drawable/custom_cancel_button"
		    android:text="@string/cancel_text" />

	</LinearLayout>

	<!-- Text Line for Required -->
	<TextView
		android:layout_height="wrap_content"
		android:layout_width="wrap_content"
		android:text="@string/required_text"
		android:textColor="#d40000"
		android:gravity="left"
		android:layout_marginLeft="10dp" />

	<!-- Middle Linear Layout -->
	<LinearLayout
	    android:layout_width="wrap_content"
	    android:layout_height="wrap_content"
	    android:orientation="horizontal"
	    android:gravity="center"
	    android:layout_marginLeft="30dp">

	    <!-- Button for Pictures -->
	    <ImageButton
	        android:id="@+id/photo_button"
	        android:layout_width="96dp"
	        android:layout_height="match_parent"
	        android:src="@drawable/ic_launcher" />

	    <!-- Item Linear Layout -->
	    <LinearLayout
	        android:layout_width="wrap_content"
	        android:layout_height="wrap_content"
	        android:orientation="vertical" >

	       <LinearLayout
	            android:layout_width="wrap_content"
	            android:layout_height="wrap_content" >

	            <!-- Button for bringing up the QR Scanner -->
	            <Button
	                android:id="@+id/qr_button"
	                style="?android:attr/buttonStyleSmall"
	                android:layout_width="wrap_content"
	                android:layout_height="match_parent"
	                android:text="@string/button_for_QR" />

	            <TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="@string/set_id_no_text" />

	            <TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="*"
	                android:textColor="#d40000" />

	            <EditText
	                android:id="@+id/item_number_edittext"
	                android:layout_width="214dp"
	                android:layout_height="wrap_content"
	                android:height="25dp"
	                android:width="25dp" >

	                <requestFocus />

	            </EditText>

	        </LinearLayout>

	        <!-- Name Linear Layout -->
	        <LinearLayout
	            android:layout_width="wrap_content"
	            android:layout_height="wrap_content" >

	            <TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="@string/set_name_text" />

	            <TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="*"
	                android:textColor="#d40000" />

	            <EditText
	                android:id="@+id/name_edittext"
	                android:layout_width="271dp"
	                android:layout_height="wrap_content"
	                android:inputType="" />

	        </LinearLayout>

	        <!-- Category Linear Layout -->
	        <LinearLayout
	            android:layout_width="wrap_content"
	            android:layout_height="wrap_content" >

	            <TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="@string/set_category_text" />

	            <Spinner
	                android:layout_height="wrap_content"
	                android:layout_width="wrap_content"
	                android:id="@+id/category_spinner"/>

				<TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="*"
	                android:textColor="#d40000" />

	       	<!--<EditText
	                android:id="@+id/category_edittext"
	                android:layout_width="238dp"
	                android:layout_height="wrap_content"
	                android:height="25dp"
	                android:width="25dp" /> -->

	        </LinearLayout>

	    </LinearLayout>

	</LinearLayout>

	<!-- Description Linear Layout -->

	<LinearLayout
	    android:layout_width="254dp"
	    android:layout_height="wrap_content"
	    android:layout_marginLeft="30dp"
	    android:orientation="vertical" >

	    <!-- Text Linear Layout -->
    	<LinearLayout
	        android:layout_width="wrap_content"
	    	android:layout_height="wrap_content"
	    	android:orientation="horizontal">

        <TextView
	        android:layout_width="wrap_content"
	        android:layout_height="wrap_content"
	        android:text="@string/set_description_text"/>

    	<TextView
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="*"
             android:textColor="#d40000" />

	    </LinearLayout>

	    <EditText
	        android:id="@+id/description_edittext"
	        android:layout_width="398dp"
	        android:layout_height="wrap_content"
	        android:height="25dp"
	        android:width="25dp" />

	</LinearLayout>

	<!-- Seller Linear Layout -->
	<LinearLayout
	    	android:layout_width="wrap_content"
	    	android:layout_height="wrap_content"
	    	android:orientation="vertical"
	    	android:layout_marginLeft="30dp" >

	    <!-- Text Linear Layout -->
	    <LinearLayout
	        android:layout_width="wrap_content"
	    	android:layout_height="wrap_content"
	    	android:orientation="horizontal" >

		    <TextView
		        android:layout_width="wrap_content"
		        android:layout_height="wrap_content"
		        android:text="@string/set_seller_text"/>

		    <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="*"
                android:textColor="#d40000" />
		 </LinearLayout>

	    <EditText
	        android:id="@+id/seller_edittext"
	        android:layout_width="402dp"
	        android:layout_height="wrap_content"
	        android:height="25dp"
	        android:width="25dp" />

	</LinearLayout>

	<!-- Minimum and Asking Price Linear Layouts -->
	<LinearLayout
    	android:layout_width="wrap_content"
    	android:layout_height="wrap_content"
    	android:orientation="horizontal"
    	android:layout_marginLeft="30dp">

	    <!-- Minimum Price Linear Layout -->
	    <LinearLayout
	        android:layout_width="wrap_content"
	    	android:layout_height="wrap_content"
	    	android:orientation="vertical"
	    	android:layout_marginRight="20dp" >

	        <!-- Text Linear Layout -->
        	<LinearLayout
        	    android:layout_width="wrap_content"
    			android:layout_height="wrap_content"
    			android:orientation="horizontal">

       	    <TextView
		        android:layout_width="wrap_content"
		        android:layout_height="wrap_content"
		        android:text="@string/set_minimum_price_text"/>

      			<TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="*"
                android:textColor="#d40000" />

	        </LinearLayout>

		    <EditText
		        android:id="@+id/minimumPrice_edittext"
		        android:layout_width="match_parent"
		        android:layout_height="wrap_content"
		        android:ems="4"
		        android:height="25dp"
		        android:width="25dp" />

	    </LinearLayout>

	    <!-- Asking Price Linear Layout -->
		<LinearLayout
		    android:layout_width="wrap_content"
	    	android:layout_height="wrap_content"
	    	android:orientation="vertical"
	    	android:layout_marginLeft="20dp" >

		    <!-- Text Linear Layout -->
		    <LinearLayout
		        android:layout_width="wrap_content"
	    		android:layout_height="wrap_content"
	    		android:orientation="horizontal" >

		        <TextView
			        android:layout_width="wrap_content"
			        android:layout_height="wrap_content"
			        android:text="@string/set_asking_price_text"
			        android:layout_marginLeft="10dp"/>

		    	<TextView
	                android:layout_width="wrap_content"
	                android:layout_height="wrap_content"
	                android:text="*"
	                android:textColor="#d40000"
	                android:layout_marginRight="10dp" />
		    </LinearLayout>

		    <EditText
		        android:id="@+id/askingPrice_edittext"
		        android:layout_width="match_parent"
		        android:layout_height="wrap_content"
		        android:ems="50"
		        android:height="25dp"
		        android:width="25dp" />

	    </LinearLayout>

	</LinearLayout>

	<!-- Submit Button Linear Layout -->

	<Button
	    android:id="@+id/submit_button"
	    android:layout_width="195dp"
	    android:layout_height="wrap_content"
	    android:layout_marginLeft="115dp"
	    android:layout_marginTop="20dp"
	    android:background="@drawable/custom_submit_button"
	    android:gravity="center"
	    android:text="@string/button_for_submit" />

</LinearLayout>


text:
using Dotvvm.Samples.Tests;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Riganti.Utils.Testing.Selenium.Core;
using Riganti.Utils.Testing.Selenium.Core.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DotVVM.Samples.Tests.Complex
{
    [TestClass]
    public class PostbackUpdate : SeleniumTestBase
    {
        [TestMethod]
        public void PostbackUpdate_DataContext_WrongUpdateOnPostback()
        {
            //As I am writing this, test should fail because on postback there will be two <!-- ko with: EditedArticle --/> elements inside each other instead of one.
            //Caused by DataContext, Visible, RenderSettings.Mode, PostBack.Update being all on the same div
            RunInAllBrowsers(browser =>
            {
                browser.NavigateToUrl(SamplesRouteUrls.ComplexSamples_ServerRendering_ControlUsageSample);
                browser.First("a[data-ui=show-link]").Click();
                browser.Wait(500);
                browser.First("input[data-ui=textbox]").CheckAttribute("value", v => v.Contains("a"));
            });
        }

        [TestMethod]
        public void PostbackUpdate_DataContext_RewritingAndHiding()
        {
            //As I am writing this, test should work because RenderSettings.Mode, PostBack.Update are on div that is inside div with DataContext.
            RunInAllBrowsers(browser =>
            {
                browser.NavigateToUrl(SamplesRouteUrls.ComplexSamples_ServerRendering_ControlUsageSampleRewriting);
                browser.First("a[data-ui=show-link]").Click();
                browser.Wait(500);
                browser.First("div[data-ui='context-1']").First("input[data-ui=textbox]").CheckAttribute("value", v => v.Contains("a"));
                browser.First("a[data-ui=rewrite-link]").Click();
                browser.Wait(500);
                browser.First("div[data-ui='context-2']").First("input[data-ui=textbox]").CheckAttribute("value", v => v.Contains("b"));
            });
        }

        [TestMethod]
        public void PostbackUpdate_ServerRendering_AddingIntoRepeater()
        {
            RunInAllBrowsers(browser =>
            {
                browser.NavigateToUrl(SamplesRouteUrls.ComplexSamples_ServerRendering_AddingIntoEmptyRepeater);

                //Is the item on nonempty repeater displayed?
                var articles = browser.Single("div[data-ui='nonempty-repeater']").FindElements("article[data-ui='test-article']");
                CheckArticleCount(browser, "nonempty-repeater", 1);
                articles.SingleOrDefault().Single("span[data-ui='detail-text']").CheckIfInnerTextEquals("NonEmptyArticles 1");

                //Add element and see
                browser.First("a[data-ui='add-link']").Click();
                browser.Wait(500);

                //Has nonempty repeater been updated?
                var neArticlesPostAdd = browser.Single("div[data-ui='nonempty-repeater']").FindElements("article[data-ui='test-article']");
                CheckArticleCount(browser, "nonempty-repeater", 2);
                neArticlesPostAdd[1].Single("span[data-ui='detail-text']").CheckIfInnerTextEquals("NonEmptyArticles 2");

                //Has the empty one?
                var eArticlesPostAdd = browser.Single("div[data-ui='empty-repeater']").FindElements("article[data-ui='test-article']");
                CheckArticleCount(browser, "empty-repeater", 1);
                eArticlesPostAdd.SingleOrDefault().Single("span[data-ui='detail-text']").CheckIfInnerTextEquals("EmptyArticles 1");
            });
        }

        public static void  CheckArticleCount(BrowserWrapper browser, string repeaterUiId, int expectedCount)
        {
            var articles = browser.First($"div[data-ui='{repeaterUiId}']").FindElements("article[data-ui='test-article']");
            if (articles.Count != expectedCount)
            {
                throw new UnexpectedElementStateException($"There should be only 2 article in the repeater. There are {articles.Count}");
            }
        }
    }
}


text:
package updatechecker

import (
	"bytes"
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"os"
	"testing"
	"time"
)

func TestUpdateChecker_GetLatestVersionFromURL(t *testing.T) {
	expected := "1.1.3"

	tuc, _, cleanup := newTestUpateChecker("", expected, "", t)
	defer cleanup()

	v, err := tuc.getLatestVersionFromURL()
	if err != nil {
		t.Fatal(err)
	}

	if v.String() != expected {
		t.Errorf("expected latest version to be %q, was %q", expected, v)
	}
}

func TestUpdateChecker_GetLatestVersionFromCache(t *testing.T) {
	expected := "1.1.3"

	tuc, _, cleanup := newTestUpateChecker("", "", expected, t)
	defer cleanup()

	v, _, err := tuc.getLatestVersionFromCache()
	if err != nil {
		t.Errorf("could not read version from cache")
	}

	if v.String() != expected {
		t.Errorf("expected latest version to be %q, was %q", expected, v)
	}
}

func TestUpdateChecker_GetLatestVersion_withCache(t *testing.T) {
	expected := "1.1.3"

	tuc, _, cleanup := newTestUpateChecker("2.0.0", expected, "", t)
	defer cleanup()

	v, err := tuc.getLatestVersion()
	if err != nil {
		t.Fatal(err)
	}

	if v.String() != expected {
		t.Errorf("expected latest version to be %q, was %q", expected, v)
	}
}

func TestUpdateChecker_GetLatestVersion_withoutCache(t *testing.T) {
	expected := "2.0.0"

	tuc, _, cleanup := newTestUpateChecker("", expected, "", t)
	defer cleanup()

	v, err := tuc.getLatestVersion()
	if err != nil {
		t.Fatal(err)
	}

	if v.String() != expected {
		t.Errorf("expected latest version to be %q, was %q", expected, v)
	}

	cv, _, err := tuc.getLatestVersionFromCache()
	if err != nil {
		t.Errorf("could not read version from cache")
	}

	if cv.String() != expected {
		t.Errorf("expected cached version after update to be %q, was %q", expected, v)
	}
}

func TestUpdateChecker_GetLatestVersion_withInvalidCache(t *testing.T) {
	expected := "2.0.0"

	tuc, _, cleanup := newTestUpateChecker("", expected, "1.1.3", t)
	defer cleanup()

	invalidateCache(tuc.versionCacheFilename)

	v, err := tuc.getLatestVersion()
	if err != nil {
		t.Fatal(err)
	}

	if v.String() != expected {
		t.Errorf("expected latest version to be %q, was %q", expected, v)
	}

	cv, _, err := tuc.getLatestVersionFromCache()
	if err != nil {
		t.Errorf("could not read version from cache")
	}

	if cv.String() != expected {
		t.Errorf("expected cached version after update to be %q, was %q", expected, v)
	}
}

func TestUpdateChecker_GetLatestVersion_withError(t *testing.T) {
	tuc, _, cleanup := newTestUpateChecker("", "", "", t)
	defer cleanup()

	_, err := tuc.getLatestVersion()
	if err == nil {
		t.Errorf("expected an error, but got nil")
	}
}

func TestUpdateChecker_CheckForUpdate_withUpdateAvailable(t *testing.T) {
	tuc, out, cleanup := newTestUpateChecker("1.1.3", "2.0.0", "", t)
	defer cleanup()

	tuc.Check()

	expected := "Please consider updating the PhraseApp CLI client (1.1.3 < 2.0.0)\n"
	expected += "You can get the latest version from https://phrase.com/cli.\n"

	if out.String() != expected {
		t.Errorf("expected %q, got %q", expected, out.String())
	}
}

func TestUpdateChecker_CheckForUpdate_withNoUpdateAvailable(t *testing.T) {
	tuc, out, cleanup := newTestUpateChecker("1.1.7", "1.1.7", "", t)
	defer cleanup()

	tuc.Check()

	if out.String() != "" {
		t.Errorf("expected no output, got %q", out.String())
	}
}

func TestUpdateChecker_CheckForUpdate_withDevVersion(t *testing.T) {
	tuc, out, cleanup := newTestUpateChecker("1.1.3-dev", "2.0.0", "", t)
	defer cleanup()

	tuc.Check()

	expected := "You're running a development version (1.1.3-dev) of the PhraseApp client! Latest version is 2.0.0.\n"

	if out.String() != expected {
		t.Errorf("expected %q, got %q", expected, out.String())
	}
}

func newTestUpateChecker(version, latestReleaseVersion, latestCachedVersion string, t *testing.T) (*Checker, *bytes.Buffer, func()) {
	url, stopServer := setupTestServer(latestReleaseVersion)

	file, err := ioutil.TempFile("", "phraseapp_update-check_test")
	if err != nil {
		t.Fatal(err)
	}
	file.Write([]byte(latestCachedVersion))
	file.Close()

	out := &bytes.Buffer{}

	tuc := New(version, file.Name(), url, out)

	return tuc, out, func() {
		stopServer()
		os.Remove(file.Name())
	}
}

func setupTestServer(version string) (string, func()) {
	s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Location", "https://github.com/phrase/phraseapp-client/releases/tag/"+version)
		w.WriteHeader(http.StatusFound)
	}))

	return s.URL, s.Close
}

func invalidateCache(filename string) {
	info, _ := os.Stat(filename)
	os.Chtimes(filename, time.Now(), info.ModTime().Add(-48*time.Hour))
}


text:
package put.ci.cevo.util;

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class MapUtils {

	public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAscending(Map<K, V> map) {
		return sortByValue(map, (o1, o2) -> o1.getValue().compareTo(o2.getValue()));
	}

	public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueDescending(Map<K, V> map) {
		return sortByValue(map, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));
	}

	private static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map,
			Comparator<Map.Entry<K, V>> comparator) {

		List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
		Collections.sort(list, comparator);

		Map<K, V> result = new LinkedHashMap<>();
		for (Map.Entry<K, V> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}

		return result;
	}
}


text:
package com.amazonaws.services.ec2.model.transform;

import javax.xml.stream.events.XMLEvent;
import javax.annotation.Generated;

import com.amazonaws.services.ec2.model.*;
import com.amazonaws.transform.Unmarshaller;

import com.amazonaws.transform.StaxUnmarshallerContext;
import com.amazonaws.transform.SimpleTypeStaxUnmarshallers.*;

/**
 * ScheduledInstancesBlockDeviceMapping StAX Unmarshaller
 */

@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class ScheduledInstancesBlockDeviceMappingStaxUnmarshaller implements Unmarshaller<ScheduledInstancesBlockDeviceMapping, StaxUnmarshallerContext> {

    public ScheduledInstancesBlockDeviceMapping unmarshall(StaxUnmarshallerContext context) throws Exception {
        ScheduledInstancesBlockDeviceMapping scheduledInstancesBlockDeviceMapping = new ScheduledInstancesBlockDeviceMapping();
        int originalDepth = context.getCurrentDepth();
        int targetDepth = originalDepth + 1;

        if (context.isStartOfDocument())
            targetDepth += 1;

        while (true) {
            XMLEvent xmlEvent = context.nextEvent();
            if (xmlEvent.isEndDocument())
                return scheduledInstancesBlockDeviceMapping;

            if (xmlEvent.isAttribute() || xmlEvent.isStartElement()) {

                if (context.testExpression("DeviceName", targetDepth)) {
                    scheduledInstancesBlockDeviceMapping.setDeviceName(StringStaxUnmarshaller.getInstance().unmarshall(context));
                    continue;
                }

                if (context.testExpression("Ebs", targetDepth)) {
                    scheduledInstancesBlockDeviceMapping.setEbs(ScheduledInstancesEbsStaxUnmarshaller.getInstance().unmarshall(context));
                    continue;
                }

                if (context.testExpression("NoDevice", targetDepth)) {
                    scheduledInstancesBlockDeviceMapping.setNoDevice(StringStaxUnmarshaller.getInstance().unmarshall(context));
                    continue;
                }

                if (context.testExpression("VirtualName", targetDepth)) {
                    scheduledInstancesBlockDeviceMapping.setVirtualName(StringStaxUnmarshaller.getInstance().unmarshall(context));
                    continue;
                }
            } else if (xmlEvent.isEndElement()) {
                if (context.getCurrentDepth() < originalDepth) {
                    return scheduledInstancesBlockDeviceMapping;
                }
            }
        }
    }

    private static ScheduledInstancesBlockDeviceMappingStaxUnmarshaller instance;

    public static ScheduledInstancesBlockDeviceMappingStaxUnmarshaller getInstance() {
        if (instance == null)
            instance = new ScheduledInstancesBlockDeviceMappingStaxUnmarshaller();
        return instance;
    }
}