text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

class Admin_model extends CI_model {

    public function login($data) {
        if(!$data['email'] && !$data['password']) return FALSE;
        $sql = "SELECT id, username, permissions,status,type,request_id FROM twex_accounts WHERE email = ? AND password = ?";
        $query = $this->db->query($sql, $data);
        $result = $query->row_array();
        $result['status'] = ($query->num_rows() > 0) ? TRUE : FALSE;
        return $result;
    }

    public function get_user_details($data){
      $this->db->select('id,username,email,status');
      $query = $this->db->get_where('twex_accounts',['email'=>$data['mail']]);
      $result=$query->result_array();

      if($query){
          $response = ['status'=>TRUE,'data'=>$result];
      }else{
          $response = ['status'=>FALSE,'data'=>[]];
      }
      return $response;
    }

    public function password_reset($data){
        $query = $this->db->update('twex_accounts',['password'=>md5($data['new_pass'])],['id'=>$data['id']]);
        $result = ($query)? TRUE:FALSE;
        return $result;
    }

    public function password_verify($data){

        $query = $this->db->get_where('twex_accounts',['id'=>$data['id'],'password'=>md5($data['pass'])]);
        if($query->num_rows()>0){
            return true;
        }else{
            return false;
        }
    }
}


text:
package pl.programa.beerquest.app;

import java.util.ArrayList;
import java.util.UUID;

import com.google.android.gms.plus.PlusClient;

import pl.programa.beerquest.LoginActivity;
import pl.programa.beerquest.model.Quest;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.preference.PreferenceManager;
import android.util.Log;

/**
 * class specifies application functional blocks
 * @author Programa.pl
 */
public class App extends Application {

	ArrayList <String> errors;
	//map refresh interval
	public static final int MILISEC_MAP_REFRESH = 15000;

    private static PlusClient mPlusClient;

	/**
	 * instance of App
	 */
	private static App instance;

	private static Quest q;

	public static Quest setQ(Quest quest){
		q = quest;
		return q;
	}

	public static Quest getQ(){
		return q;
	}

	public App() {
		instance = this;
	}

	public static Context getContext() {
		return instance;
	}

	public static PlusClient setMPlusClient(PlusClient mPlusC){
        mPlusClient = mPlusC;
		return mPlusClient;
	}

	public static PlusClient getMPlusClient(){
		return mPlusClient;
	}

	/**
	 * SPINNER API ASYNC TASK COUTNER inceremented on pre execute, decremented
	 * on post execute. Informs if any data is being downloaded or uploaded.
	 */
	public static int apiCount = 0;

	/**
	 *
	 * @param ctx
	 * @param newLoginIntent
	 */
	public static void logoutClicked(Context ctx, Boolean newLoginIntent) {
		((App) ctx.getApplicationContext()).setLogin(null);
		logoutAndWipeData(ctx, newLoginIntent);
	}

	/**
	 *
	 * @param ctx
	 * @param newLoginIntent
	 */
	public static void logout(Context ctx, Boolean newLoginIntent) {
		((App) ctx.getApplicationContext()).setLoggedIn(false);
		if (newLoginIntent) {
			Intent intent = new Intent(ctx, LoginActivity.class);
			ctx.startActivity(intent);
		}
	}

	/**
	 *
	 * @param ctx
	 */
	public static void logoutClose(Context ctx) {
		((App) ctx.getApplicationContext()).setLoggedIn(false);
	}

	/**
	 *
	 * @param context
	 * @param newLoginIntent
	 */
	public static void logoutAndWipeData(Context context, Boolean newLoginIntent) {
		App.logv("logoutAndWipeData");
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
		Editor editor = prefs.edit();
		editor.commit();
		logout(context, newLoginIntent);
	}

	/**
	 * Preferences
	 */
	private static final String PREFS_LOGIN = "PREFS_LOGIN";
	private static final String PREFS_TOKEN = "PREFS_TOKEN";
	private static final String PREFS_ID = "PREFS_ID";
	private static final String PREFS_IS_LOGGED_IN = "PREFS_IS_LOGGED_IN";

	/**
	 * get login
	 * @return
	 */
	public String getLogin() {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		return prefs.getString(PREFS_LOGIN, null);
	}

	/**
	 * set login
	 * @param login
	 */
	public void setLogin(String login) {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		Editor editor = prefs.edit();
		editor.putString(PREFS_LOGIN, login);
		editor.commit();
	}

	/**
	 * get token
	 * @return
	 */
	public String getToken() {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		return prefs.getString(PREFS_TOKEN, "#beerquest#");
	}
	/**
	 *
	 * set token
	 */
	public void setToken(String token) {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		Editor editor = prefs.edit();
		editor.putString(PREFS_TOKEN, token);
		editor.commit();
	}

	/**
	 * getId
	 * @return
	 */
	public Long getId() {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		return prefs.getLong(PREFS_ID, -1l);
	}

	/**
	 * setId
	 * @param id
	 */
	public void setId(Long id) {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		Editor editor = prefs.edit();
		editor.putLong(PREFS_ID, id);
		editor.commit();
	}

	/**
	 * check if user is logged
	 * @return
	 */
	public Boolean isLoggedIn() {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		return prefs.getBoolean(PREFS_IS_LOGGED_IN, false);
	}

	/**
	 *
	 * @param isLoggedIn
	 */
	public void setLoggedIn(Boolean isLoggedIn) {
		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
		Editor editor = prefs.edit();
		editor.putBoolean(PREFS_IS_LOGGED_IN, isLoggedIn);
		editor.commit();
	}

	/**
	 * Logs
	 */
	private final static int VERBOSE = 5;
	private final static int INFORMATION = 4;
	private final static int WARNING = 3;
	private final static int DEBUG = 2;
	private final static int ERROR = 1;

	// 0 disables debug
	public final static int DEBUG_LVL = VERBOSE;
	public final static boolean DEBUG_DB = true;

	public final static String TAG = "beerquest";

	/**
	 *
	 * @param message
	 */
	public static void logdb(String message) {
		if (DEBUG_DB && message != null)
			Log.v(TAG, message);
	}

	/**
	 *
	 * @param message
	 */
	public static void logv(String message) {
		if (DEBUG_LVL >= 5 && message != null)
			Log.v(TAG, message);
	}

	/**
	 *
	 * @param message
	 */
	public static void logi(String message) {
		if (DEBUG_LVL >= 4 && message != null)
			Log.v(TAG, message);
	}
	/**
	 *
	 * @param message
	 */
	public static void logw(String message) {
		if (DEBUG_LVL >= 3 && message != null)
			Log.v(TAG, message);
	}

	/**
	 *
	 * @param message
	 */
	public static void logd(String message) {
		if (DEBUG_LVL >= 2 && message != null)
			Log.v(TAG, message);
	}

	/**
	 *
	 * @param message
	 */
	public static void loge(String message) {
		if (DEBUG_LVL >= 1 && message != null)
			Log.v(TAG, message);
	}

	/*
	 * Unique DEVICE ID
	 */
	private static String uniqueID = null;
	private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";

	public synchronized static String getDeviceId(Context context) {
		if (uniqueID == null) {
			SharedPreferences sharedPrefs = context.getSharedPreferences(PREF_UNIQUE_ID, Context.MODE_PRIVATE);
			uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
			if (uniqueID == null) {
				uniqueID = UUID.randomUUID().toString();
				Editor editor = sharedPrefs.edit();
				editor.putString(PREF_UNIQUE_ID, uniqueID);
				editor.commit();
			}
		}
		return uniqueID;
	}

}

redpajama_set_name: RedPajamaGithub


text:
try:
    import os, sys
    module = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.insert(0, module)
    from netkiller.docker import *
except ImportError as err:
	print("%s" %(err))

fluentd = Services('fluentd')
fluentd.image('fluent/fluentd:latest').container_name('fluentd').hostname('fluentd.sfzito.com').restart('always')
fluentd.volumes(
	[
		'/opt/sfzito.com/ops.sfzito.com/fluentd/conf/fluentd.conf:/fluentd/etc/fluentd.conf',
		'/var/log/fluentd:/var/log/fluentd'
	]
).ports("24224:24224").environment(['FLUENTD_CONF=fluentd.conf'])

logging = Composes('logging')
logging.version('3.9')
# logging.env({'DOCKER_HOST': 'ssh://root@192.168.30.11'})
# logging.volumes(volumes)
logging.services(fluentd)


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using MvcContrib.PortableAreas;

namespace Appleseed.Core.ApplicationBus
{
    public class JSRegisterDescriptor : IEventMessage
    {
        public List<string> Scripts { get; set; }

    }
}


text:
package thereisnospon.acclient.data;

import android.util.Log;

import com.orhanobut.logger.Logger;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by yzr on 16/6/7.
 */
public class SearchProblem extends ProblemItem
{

    String author;
    String source;

    public SearchProblem(int id, String title, String author, String source, int accepted, int submission) {
       super(id,title,accepted,submission);
        this.author = author;
        this.source = source;
    }

    public static class Builder{

        public static List<SearchProblem> parse(String html){
            Log.d("SSEARCH","parse");
            Document document= Jsoup.parse(html);
            Log.d("SSEARCH",html);
            Element tbody=document.getElementsByTag("TBODY").first();

            Elements trs=tbody.getElementsByTag("tr");
            List<SearchProblem>list=new ArrayList<>();
            for(int i=0;i<trs.size();i++){
                Element tr=trs.get(i);
                if(tr.children().first().hasClass("TABLE_TEXT")){
                    SearchProblem problem=get(tr);
                    if(problem!=null){
                        list.add(problem);
                    }
                }
            }
            return list;
        }

        public static final String IMG_REGX="src=\"images/([\\S\\s]+?.gif)\"";

        private static int getStatus(Element element){
            if(element==null||element.html()==null)
                return ProblemItem.UN_KNOW;
            String html=element.html();
            Pattern pattern=Pattern.compile(IMG_REGX);
            Matcher matcher=pattern.matcher(html);
            if(matcher.find()){
                String img=matcher.group(1);
                if(img.equals("ac"))
                    return ProblemItem.ACCEPTED;
                else return ProblemItem.UN_SOLVED;
            }
            return ProblemItem.UN_SUBMMIT;
        }

        private static SearchProblem getWithLogin(Element tr){
            Elements tds=tr.getElementsByTag("td");
            int status=getStatus(tds.get(0));
            int id=Integer.parseInt(tds.get(1).text());
            String title=tds.get(2).text();
            String author=tds.get(3).text();
            String source=tds.get(4).text();
            String str=tds.get(5).text();
            String nums[]=str.split("[\\(\\)/%]");

            if(nums.length!=4)
                return null;
            int accepted=Integer.parseInt(nums[1]);
            int submission=Integer.parseInt(nums[2]);
            SearchProblem problem=new SearchProblem(id,title,author,source,accepted,submission);
            problem.setStatus(status);
            Logger.e(status+"");
            return problem;
        }
        private static SearchProblem getWithout(Element tr){
            Elements tds=tr.getElementsByTag("td");
            int id=Integer.parseInt(tds.get(0).text());
            String title=tds.get(1).text();
            String author=tds.get(2).text();
            String source=tds.get(3).text();
            String str=tds.get(4).text();
            String nums[]=str.split("[\\(\\)/%]");
            if(nums.length!=4)
                return null;
            int accepted=Integer.parseInt(nums[1]);
            int submission=Integer.parseInt(nums[2]);
            SearchProblem problem=new SearchProblem(id,title,author,source,accepted,submission);
            problem.setStatus(ProblemItem.UN_KNOW);
            return problem;
        }
        private static SearchProblem get(Element tr){
            Elements tds=tr.getElementsByTag("td");
            if(tds.size()==5){
                Logger.d("out");
                return getWithout(tr);
            }else{
                Logger.d("login");
                return getWithLogin(tr);
            }
        }
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getSource() {
        return source;
    }

    public void setSource(String source) {
        this.source = source;
    }
}


text:
__author__ = 'Haleemur Ali'
"""
Tests to validate that the correct delete statement is
issued for the redshift dialect of SQL.

These tests use a simple transaction schema.

For simple delete statments that don't have a ``WHERE`` clause
or whose ``WHERE`` clause only refers to columns from the
target table, the emitted query should match that emitted
for the postgresql dialect.

However, for more complex queries, an extra ``USING`` clause is required.

For example, the following is valid in Postgresql:

.. :code-block: sql

    DELETE FROM customers
    WHERE customers.id = orders.customer_id
      AND orders.id < 100

This same query needs to be written like this in Redshift:

.. :code-block: sql
    DELETE FROM customers
    USING orders
    WHERE customers.id = orders.customer_id
      AND orders.id < 100

"""

import sqlalchemy as sa

from rs_sqla_test_utils.utils import clean, compile_query

meta = sa.MetaData()

customers = sa.Table(
    'customers', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False),
    sa.Column('first_name', sa.String(128)),
    sa.Column('last_name', sa.String(128)),
    sa.Column('email', sa.String(255))
)

orders = sa.Table(
    'orders', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False),
    sa.Column('customer_id', sa.Integer),
    sa.Column('total_invoiced', sa.Numeric(12, 4)),
    sa.Column('discount_invoiced', sa.Numeric(12, 4)),
    sa.Column('grandtotal_invoiced', sa.Numeric(12, 4)),
    sa.Column('created_at', sa.DateTime),
    sa.Column('updated_at', sa.DateTime)
)

items = sa.Table(
    'items', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False),
    sa.Column('order_id', sa.Integer),
    sa.Column('product_id', sa.Integer),
    sa.Column('name', sa.String(255)),
    sa.Column('qty', sa.Numeric(12, 4)),
    sa.Column('price', sa.Numeric(12, 4)),
    sa.Column('total_invoiced', sa.Numeric(12, 4)),
    sa.Column('discount_invoiced', sa.Numeric(12, 4)),
    sa.Column('grandtotal_invoiced', sa.Numeric(12, 4)),
    sa.Column('created_at', sa.DateTime),
    sa.Column('updated_at', sa.DateTime)
)

product = sa.Table(
    'products', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False),
    sa.Column('parent_id', sa.Integer),
    sa.Column('name', sa.String(255)),
    sa.Column('price', sa.Numeric(12, 4))
)

ham = sa.Table(
    'ham', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False)
)

spam = sa.Table(
    'spam', meta,
    sa.Column('id', sa.Integer, primary_key=True, autoincrement=False)
)

hammy_spam = sa.Table(
    'ham, spam', meta,
    sa.Column('ham_id', sa.Integer, sa.ForeignKey('ham.id')),
    sa.Column('spam_id', sa.Integer, sa.ForeignKey('spam.id'))
)

def test_delete_stmt_nowhereclause():
    del_stmt = sa.delete(customers)
    assert clean(compile_query(del_stmt)) == 'DELETE FROM customers'

def test_delete_stmt_simplewhereclause1():
    del_stmt = sa.delete(customers).where(
        customers.c.email == 'test@test.test'
    )
    expected = """
        DELETE FROM customers
        WHERE customers.email = 'test@test.test'"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_simplewhereclause2():
    del_stmt = sa.delete(customers).where(
        customers.c.email.endswith('test.com')
    )
    expected = """
        DELETE FROM customers
        WHERE customers.email
        LIKE '%%' || 'test.com'"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_joinedwhereclause1():
    del_stmt = sa.delete(orders).where(
        orders.c.customer_id == customers.c.id
    )
    expected = """
        DELETE FROM orders
        USING customers
        WHERE orders.customer_id = customers.id"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_joinedwhereclause2():
    del_stmt = sa.delete(
        orders
    ).where(
        orders.c.customer_id == customers.c.id
    ).where(
        orders.c.id == items.c.order_id
    ).where(
        customers.c.email.endswith('test.com')
    ).where(
        items.c.name == 'test product'
    )
    expected = """
      DELETE FROM orders
      USING customers, items
      WHERE orders.customer_id = customers.id
      AND orders.id = items.order_id
      AND (customers.email LIKE '%%' || 'test.com')
      AND items.name = 'test product'"""

    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_subqueryplusjoin():
    del_stmt = sa.delete(
        orders
    ).where(
        orders.c.customer_id.in_(
            sa.select(
                [customers.c.id]
            ).where(customers.c.email.endswith('test.com'))
        )
    ).where(
        orders.c.id == items.c.order_id
    ).where(
        items.c.name == 'test product'
    )
    expected = """
      DELETE FROM orders
      USING items
      WHERE orders.customer_id IN
      (SELECT customers.id
      FROM customers
      WHERE (customers.email LIKE '%%' || 'test.com'))
      AND orders.id = items.order_id
      AND items.name = 'test product'"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_subquery():
    del_stmt = sa.delete(
        orders
    ).where(
        orders.c.customer_id.in_(
            sa.select(
                [customers.c.id]
            ).where(customers.c.email.endswith('test.com'))
        )
    )
    expected = """
        DELETE FROM orders
        WHERE orders.customer_id IN
        (SELECT customers.id
        FROM customers
        WHERE (customers.email LIKE '%%' || 'test.com'))"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_on_subquerycomma():
    del_stmt = sa.delete(
        ham
    ).where(
        ham.c.id.in_(
            sa.select(
                [hammy_spam.c.ham_id]
            )
        )
    )
    expected = """
        DELETE FROM ham
        WHERE ham.id IN
        (SELECT "ham, spam".ham_id
        FROM "ham, spam")"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_on_comma():
    del_stmt = sa.delete(ham).where(ham.c.id == hammy_spam.c.ham_id)
    expected = """
        DELETE FROM ham USING "ham, spam"
        WHERE ham.id = "ham, spam".ham_id"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_on_alias():
    parent_ = sa.alias(product)
    del_stmt = sa.delete(
        product
    ).where(product.c.parent_id == parent_.c.id)
    expected = """
        DELETE FROM products
        USING products AS products_1
        WHERE products.parent_id = products_1.id"""
    assert clean(compile_query(del_stmt)) == clean(expected)

def test_delete_stmt_with_comma_subquery_alias_join():
    parent_ = sa.alias(product)

    del_stmt = sa.delete(
        items
    ).where(
        items.c.order_id == orders.c.id
    ).where(
        orders.c.customer_id.in_(
            sa.select([customers.c.id]).where(
                customers.c.email.endswith('test.com')
            )
        )
    ).where(
        items.c.product_id == product.c.id
    ).where(
        product.c.parent_id == parent_.c.id
    ).where(
        parent_.c.id != hammy_spam.c.ham_id
    )

    expected = """
        DELETE FROM items
        USING orders, products, products AS products_1, "ham, spam"
        WHERE items.order_id = orders.id
        AND orders.customer_id IN
        (SELECT customers.id
        FROM customers
        WHERE (customers.email LIKE '%%' || 'test.com'))
        AND items.product_id = products.id
        AND products.parent_id = products_1.id
        AND products_1.id != "ham, spam".ham_id"""

    assert clean(compile_query(del_stmt)) == clean(expected)


text:
#ifndef DEFINEMANAGER_H
#define DEFINEMANAGER_H

#include "JZCommonDefine.h"
#include "LexData.h"

using namespace std;

/*
 * This class will manage the command line factor, too
 *
 */

class DefineRec
{
public:
	string key;
	bool isFuncLikeMacro;
	bool isVarArgs;
	string defineStr;		//if it is an empty macro,this will be empty
	LexRecList formalParam;		//use when this is a funclike macro
	ParamSiteMap paramMap;

  DefineRec();
} ;

typedef map<string ,DefineRec> DefineRecMap;

class DefineManager {
public:
	enum DefineManagerReturnCode
	{
		eDefMgrNotDefined = 0,
		eDefMgrDefined = 1,
		eDefMgrDoubleDefineMacro = 2,
		eDefMgrKeyDiffFromSrc = 3,

		//put this at last
		eDefMgrNoError
	};

	DefineManager ();
	virtual ~DefineManager ();

  //I don't think it's a good idea to have global instance for these class now.

	static DefineManager* getGlobalInstance();
	void init();

	//if not defined ,return NULL
	const DefineRec* findDefineMap(const string& srcDefine);

	DefineManagerReturnCode isDefined(const string& src);

	//will return error code
	DefineManagerReturnCode addDefineMap(const string& src, const DefineRec& rec);

  DefineManagerReturnCode cancelDefine(const string& src);

	void printAllDefine();
	uint32 getDefineNum();

private:
	DefineRecMap mSrcLexMap;
	StringSet mCanceledDefine;
};

#endif /* end of include guard: DEFINEMANAGER_H */


text:
@class Parse, AIOrder;

@interface AIServerManager : NSObject

@property (strong, nonatomic) LYRClient* client;

+ (AIServerManager*) sharedManager;

#pragma mark - Parse

- (void) placeNewOrder: (AIOrder*) order
             onSuccess:(void(^)(BOOL success)) success
             onFailure:(void(^)(NSError* error)) failure;

- (void) getOrdersWithType:(AIOrdersToDisplay) type
                 onSuccess:(void(^)(NSArray* array)) success
                 onFailure:(void(^)(NSError* error)) failure;

- (void) setNewStatus: (NSString*) status
              toOrder: (AIOrder*) order
            onSuccess:(void(^)(BOOL success)) success
            onFailure:(void(^)(NSError* error)) failure;

#pragma mark - Layer

- (void) queryAndCacheUsersWithIDs:(NSArray*)userIDs
                        completion: (void(^)(NSArray* participants, NSError* error))completion;

- (PFUser*) cachedUserForUserID:(NSString*) userID;
- (void) cacheUserIfNeeded:(PFUser*) user;
- (NSArray*) unCachedUserIDsFromParticipants:(NSArray*) participants;
- (NSArray*) resolvedNamesFromParticipants:(NSArray*) participants;

@end


text:
/*jshint forin:true, noarg:true, noempty:true, eqeqeq:true, bitwise:true, strict:true, undef:true, unused:true, curly:true, node:true, indent:4, maxerr:50, globalstrict:true */

"use strict";

var DELAY = 500;

var lib = require("./lib");
var http = require("./http");
var assurt = require("./assurt");
var fishback = require("../lib/fishback");
var assert = require("assert");

var response = {
    url: "/",
    method: "GET",
    statusCode: 200,
    headers: { "x-cache": "MISS", "cache-control": "public, max-age=60" },
    data: [ "Hello, World!\n" ]
};

lib.getCacheList(function (cache) {

    var client = new fishback.Client(null, null, {
        request: function (options, callback) {
            var clientResponse = new http.ClientResponse(response);
            callback(clientResponse);
            clientResponse.fire();
            return new http.ClientRequest();
        }
    });

    var proxy = fishback.createCachingProxy(cache, client);

    lib.step([

        function (next) {
            var req = new http.ServerRequest({ url: "/", method: "GET" });
            var res = new http.ServerResponse();
            res.on('end', assurt.calls(function () {
                assert.equal(res.headers["x-cache"], "MISS");
                setTimeout(next, DELAY);
            }));
            proxy.request(req, res);
            req.fire();
        },

        function (next) {
            var req = new http.ServerRequest({ url: "/", method: "GET" });
            var res = new http.ServerResponse();
            res.on('end', assurt.calls(function () {
                assert.equal(res.headers["x-cache"], "HIT");
                next.call();
            }));
            proxy.request(req, res);
            req.fire();
        },

        function (next) {
            var req = new http.ServerRequest({ url: "/", method: "GET" });
            var res = new http.ServerResponse();
            res.on('end', assurt.calls(function () {
                assert.equal(res.headers["x-cache"], "HIT");
                next.call();
            }));
            proxy.request(req, res);
            req.fire();
        },

        function (next) {
            var req = new http.ServerRequest({ url: "/", method: "GET" });
            var res = new http.ServerResponse();
            res.on('end', assurt.calls(function () {
                assert.equal(res.headers["x-cache"], "HIT");
                next.call();
            }));
            proxy.request(req, res);
            req.fire();
        },

        function (next) {
            var req = new http.ServerRequest({ url: "/", method: "GET" });
            var res = new http.ServerResponse();
            res.on('end', assurt.calls(function () {
                assert.equal(res.headers["x-cache"], "HIT");
                next.call();
            }));
            proxy.request(req, res);
            req.fire();
        },

        function () {
            cache.close();
        }

    ]);

});


text:
/* @LICENSE(KBUILD_GPL) */

/*
 * "Optimize" a list of dependencies as spit out by gcc -MD
 * for the kernel build
 * ===========================================================================
 *
 * Author       Kai Germaschewski
 * Copyright    2002 by Kai Germaschewski  <kai.germaschewski@gmx.de>
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 *
 * Introduction:
 *
 * gcc produces a very nice and correct list of dependencies which
 * tells make when to remake a file.
 *
 * To use this list as-is however has the drawback that virtually
 * every file in the kernel includes autoconf.h.
 *
 * If the user re-runs make *config, autoconf.h will be
 * regenerated.  make notices that and will rebuild every file which
 * includes autoconf.h, i.e. basically all files. This is extremely
 * annoying if the user just changed CONFIG_HIS_DRIVER from n to m.
 *
 * So we play the same trick that "mkdep" played before. We replace
 * the dependency on autoconf.h by a dependency on every config
 * option which is mentioned in any of the listed prequisites.
 *
 * kconfig populates a tree in include/config/ with an empty file
 * for each config symbol and when the configuration is updated
 * the files representing changed config options are touched
 * which then let make pick up the changes and the files that use
 * the config symbols are rebuilt.
 *
 * So if the user changes his CONFIG_HIS_DRIVER option, only the objects
 * which depend on "include/linux/config/his/driver.h" will be rebuilt,
 * so most likely only his driver ;-)
 *
 * The idea above dates, by the way, back to Michael E Chastain, AFAIK.
 *
 * So to get dependencies right, there are two issues:
 * o if any of the files the compiler read changed, we need to rebuild
 * o if the command line given to the compile the file changed, we
 *   better rebuild as well.
 *
 * The former is handled by using the -MD output, the later by saving
 * the command line used to compile the old object and comparing it
 * to the one we would now use.
 *
 * Again, also this idea is pretty old and has been discussed on
 * kbuild-devel a long time ago. I don't have a sensibly working
 * internet connection right now, so I rather don't mention names
 * without double checking.
 *
 * This code here has been based partially based on mkdep.c, which
 * says the following about its history:
 *
 *   Copyright abandoned, Michael Chastain, <mailto:mec@shout.net>.
 *   This is a C version of syncdep.pl by Werner Almesberger.
 *
 *
 * It is invoked as
 *
 *   fixdep <depfile> <target> <cmdline>
 *
 * and will read the dependency file <depfile>
 *
 * The transformed dependency snipped is written to stdout.
 *
 * It first generates a line
 *
 *   cmd_<target> = <cmdline>
 *
 * and then basically copies the .<target>.d file to stdout, in the
 * process filtering out the dependency on autoconf.h and adding
 * dependencies on include/config/my/option.h for every
 * CONFIG_MY_OPTION encountered in any of the prequisites.
 *
 * It will also filter out all the dependencies on *.ver. We need
 * to make sure that the generated version checksum are globally up
 * to date before even starting the recursive build, so it's too late
 * at this point anyway.
 *
 * The algorithm to grep for "CONFIG_..." is bit unusual, but should
 * be fast ;-) We don't even try to really parse the header files, but
 * merely grep, i.e. if CONFIG_FOO is mentioned in a comment, it will
 * be picked up as well. It's not a problem with respect to
 * correctness, since that can only give too many dependencies, thus
 * we cannot miss a rebuild. Since people tend to not mention totally
 * unrelated CONFIG_ options all over the place, it's not an
 * efficiency problem either.
 *
 * (Note: it'd be easy to port over the complete mkdep state machine,
 *  but I don't think the added complexity is worth it)
 */
/*
 * Note 2: if somebody writes HELLO_CONFIG_BOOM in a file, it will depend onto
 * CONFIG_BOOM. This could seem a bug (not too hard to fix), but please do not
 * fix it! Some UserModeLinux files (look at arch/um/) call CONFIG_BOOM as
 * UML_CONFIG_BOOM, to avoid conflicts with /usr/include/linux/autoconf.h,
 * through arch/um/include/uml-config.h; this fixdep "bug" makes sure that
 * those files will have correct dependencies.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <ctype.h>
#include <arpa/inet.h>

#define INT_CONF ntohl(0x434f4e46)
#define INT_ONFI ntohl(0x4f4e4649)
#define INT_NFIG ntohl(0x4e464947)
#define INT_FIG_ ntohl(0x4649475f)

char *target;
char *depfile;
char *cmdline;

static void usage(void)
{
	fprintf(stderr, "Usage: fixdep <depfile> <target> <cmdline>\n");
	exit(1);
}

/*
 * Print out the commandline prefixed with cmd_<target filename> :=
 */
static void print_cmdline(void)
{
	printf("cmd_%s := %s\n\n", target, cmdline);
}

char * str_config  = NULL;
int    size_config = 0;
int    len_config  = 0;

/*
 * Grow the configuration string to a desired length.
 * Usually the first growth is plenty.
 */
static void grow_config(int len)
{
	while (len_config + len > size_config) {
		if (size_config == 0)
			size_config = 2048;
		str_config = realloc(str_config, size_config *= 2);
		if (str_config == NULL)
			{ perror("fixdep:malloc"); exit(1); }
	}
}

/*
 * Lookup a value in the configuration string.
 */
static int is_defined_config(const char * name, int len)
{
	const char * pconfig;
	const char * plast = str_config + len_config - len;
	for ( pconfig = str_config + 1; pconfig < plast; pconfig++ ) {
		if (pconfig[ -1] == '\n'
		&&  pconfig[len] == '\n'
		&&  !memcmp(pconfig, name, len))
			return 1;
	}
	return 0;
}

/*
 * Add a new value to the configuration string.
 */
static void define_config(const char * name, int len)
{
	grow_config(len + 1);

	memcpy(str_config+len_config, name, len);
	len_config += len;
	str_config[len_config++] = '\n';
}

/*
 * Clear the set of configuration strings.
 */
static void clear_config(void)
{
	len_config = 0;
	define_config("", 0);
}

/*
 * Record the use of a CONFIG_* word.
 */
static void use_config(char *m, int slen)
{
	char s[PATH_MAX];
	char *p;

	if (is_defined_config(m, slen))
	    return;

	define_config(m, slen);

	memcpy(s, m, slen); s[slen] = 0;

	for (p = s; p < s + slen; p++) {
		if (*p == '_')
			*p = '/';
		else
			*p = tolower((int)*p);
	}
	printf("    $(wildcard include/config/%s.h) \\\n", s);
}

static void parse_config_file(char *map, size_t len)
{
	int *end = (int *) (map + len);
	/* start at +1, so that p can never be < map */
	int *m   = (int *) map + 1;
	char *p, *q;

	for (; m < end; m++) {
		if (*m == INT_CONF) { p = (char *) m  ; goto conf; }
		if (*m == INT_ONFI) { p = (char *) m-1; goto conf; }
		if (*m == INT_NFIG) { p = (char *) m-2; goto conf; }
		if (*m == INT_FIG_) { p = (char *) m-3; goto conf; }
		continue;
	conf:
		if (p > map + len - 7)
			continue;
		if (memcmp(p, "CONFIG_", 7))
			continue;
		for (q = p + 7; q < map + len; q++) {
			if (!(isalnum(*q) || *q == '_'))
				goto found;
		}
		continue;

	found:
		if (!memcmp(q - 7, "_MODULE", 7))
			q -= 7;
		if( (q-p-7) < 0 )
			continue;
		use_config(p+7, q-p-7);
	}
}

/* test is s ends in sub */
static int strrcmp(char *s, char *sub)
{
	int slen = strlen(s);
	int sublen = strlen(sub);

	if (sublen > slen)
		return 1;

	return memcmp(s + slen - sublen, sub, sublen);
}

static void do_config_file(char *filename)
{
	struct stat st;
	int fd;
	void *map;

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "fixdep: ");
		perror(filename);
		exit(2);
	}
	fstat(fd, &st);
	if (st.st_size == 0) {
		close(fd);
		return;
	}
	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if ((long) map == -1) {
		perror("fixdep: mmap");
		close(fd);
		return;
	}

	parse_config_file(map, st.st_size);

	munmap(map, st.st_size);

	close(fd);
}

static void parse_dep_file(void *map, size_t len)
{
	char *m = map;
	char *end = m + len;
	char *p;
	char s[PATH_MAX];

	p = strchr(m, ':');
	if (!p) {
		fprintf(stderr, "fixdep: parse error\n");
		exit(1);
	}
	memcpy(s, m, p-m); s[p-m] = 0;
	printf("deps_%s := \\\n", target);
	m = p+1;

	clear_config();

	while (m < end) {
		while (m < end && (*m == ' ' || *m == '\\' || *m == '\n'))
			m++;
		p = m;
		while (p < end && *p != ' ') p++;
		if (p == end) {
			do p--; while (!isalnum(*p));
			p++;
		}
		memcpy(s, m, p-m); s[p-m] = 0;
		if (strrcmp(s, "include/generated/autoconf.h") &&
		    strrcmp(s, "arch/um/include/uml-config.h") &&
		    strrcmp(s, ".ver")) {
			printf("  %s \\\n", s);
			do_config_file(s);
		}
		m = p + 1;
	}
	printf("\n%s: $(deps_%s)\n\n", target, target);
	printf("$(deps_%s):\n", target);
}

static void print_deps(void)
{
	struct stat st;
	int fd;
	void *map;

	fd = open(depfile, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "fixdep: ");
		perror(depfile);
		exit(2);
	}
	fstat(fd, &st);
	if (st.st_size == 0) {
		fprintf(stderr,"fixdep: %s is empty\n",depfile);
		close(fd);
		return;
	}
	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if ((long) map == -1) {
		perror("fixdep: mmap");
		close(fd);
		return;
	}

	parse_dep_file(map, st.st_size);

	munmap(map, st.st_size);

	close(fd);
}

static void traps(void)
{
	static char test[] __attribute__((aligned(sizeof(int)))) = "CONF";
	int *p = (int *)test;

	if (*p != INT_CONF) {
		fprintf(stderr, "fixdep: sizeof(int) != 4 or wrong endianess? %#x\n",
			*p);
		exit(2);
	}
}

int main(int argc, char *argv[])
{
	traps();

	if (argc != 4)
		usage();

	depfile = argv[1];
	target = argv[2];
	cmdline = argv[3];

	print_cmdline();
	print_deps();

	return 0;
}


text:
<?php

/**
 * Pressed78RPMDisc filter form base class.
 *
 * @package    mediaSCORE
 * @subpackage filter
 * @author     Nouman Tayyab
 * @version    SVN: $Id: sfDoctrineFormFilterGeneratedTemplate.php 29570 2010-05-21 14:49:47Z Kris.Wallsmith $
 */
abstract class BasePressed78RPMDiscFormFilter extends BaseFormFilterDoctrine
{
  public function setup()
  {
    $this->setWidgets(array(
      'quantity'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'generation'                      => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'year_recorded'                   => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'copies'                          => new sfWidgetFormFilterInput(),
      'stock_brand'                     => new sfWidgetFormFilterInput(),
      'off_brand'                       => new sfWidgetFormFilterInput(),
      'fungus'                          => new sfWidgetFormFilterInput(),
      'other_contaminants'              => new sfWidgetFormFilterInput(),
      'duration'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'duration_type'                   => new sfWidgetFormFilterInput(),
      'type'                            => new sfWidgetFormFilterInput(),
      'material'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'oxidationcorrosion'              => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'pack_deformation'                => new sfWidgetFormFilterInput(),
      'noise_reduction'                 => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'tape_type'                       => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'thin_tape'                       => new sfWidgetFormFilterInput(),
      'slow_speed'                      => new sfWidgetFormFilterInput(),
      'sound_field'                     => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'soft_binder_syndrome'            => new sfWidgetFormFilterInput(),
      'gauge'                           => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'color'                           => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'colorfade'                       => new sfWidgetFormFilterInput(),
      'soundtrackformat'                => new sfWidgetFormFilterInput(),
      'substrate'                       => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'strongodor'                      => new sfWidgetFormFilterInput(),
      'vinegarodor'                     => new sfWidgetFormFilterInput(),
      'adstriplevel'                    => new sfWidgetFormFilterInput(),
      'shrinkage'                       => new sfWidgetFormFilterInput(),
      'levelofshrinkage'                => new sfWidgetFormFilterInput(),
      'rust'                            => new sfWidgetFormFilterInput(),
      'discoloration'                   => new sfWidgetFormFilterInput(),
      'surfaceblisteringbubbling'       => new sfWidgetFormFilterInput(),
      'thintape'                        => new sfWidgetFormFilterInput(),
      '1993orearlier'                   => new sfWidgetFormFilterInput(),
      'datagradetape'                   => new sfWidgetFormFilterInput(),
      'longplay32k96k'                  => new sfWidgetFormFilterInput(),
      'corrosionrustoxidation'          => new sfWidgetFormFilterInput(),
      'composition'                     => new sfWidgetFormFilterInput(),
      'nonstandardbrand'                => new sfWidgetFormFilterInput(),
      'trackconfiguration'              => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'tapethickness'                   => new sfWidgetFormFilterInput(),
      'speed'                           => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'softbindersyndrome'              => new sfWidgetFormFilterInput(),
      'materialsbreakdown'              => new sfWidgetFormFilterInput(),
      'physicaldamage'                  => new sfWidgetFormFilterInput(),
      'delamination'                    => new sfWidgetFormFilterInput(),
      'plasticizerexudation'            => new sfWidgetFormFilterInput(),
      'recordinglayer'                  => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'recordingspeed'                  => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'cylindertype'                    => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'reflectivelayer'                 => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'datalayer'                       => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'opticaldisctype'                 => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'format'                          => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'recordingstandard'               => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'publicationyear'                 => new sfWidgetFormFilterDate(array('from_date' => new sfWidgetFormDate(), 'to_date' => new sfWidgetFormDate(), 'with_empty' => false)),
      'capacitylayers'                  => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'codec'                           => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'datarate'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'sheddingsoftbinder'              => new sfWidgetFormFilterInput(),
      'formatversion'                   => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'oxide'                           => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'bindersystem'                    => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'reelsize'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'whiteresidue'                    => new sfWidgetFormFilterInput(),
      'size'                            => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'formattypedvideorecordingformat' => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'bitrate'                         => new sfWidgetFormFilterInput(),
      'scanning'                        => new sfWidgetFormFilterInput(array('with_empty' => false)),
      'created_at'                      => new sfWidgetFormFilterDate(array('from_date' => new sfWidgetFormDate(), 'to_date' => new sfWidgetFormDate(), 'with_empty' => false)),
      'updated_at'                      => new sfWidgetFormFilterDate(array('from_date' => new sfWidgetFormDate(), 'to_date' => new sfWidgetFormDate(), 'with_empty' => false)),
    ));

    $this->setValidators(array(
      'quantity'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'generation'                      => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'year_recorded'                   => new sfValidatorPass(array('required' => false)),
      'copies'                          => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'stock_brand'                     => new sfValidatorPass(array('required' => false)),
      'off_brand'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'fungus'                          => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'other_contaminants'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'duration'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'duration_type'                   => new sfValidatorPass(array('required' => false)),
      'type'                            => new sfValidatorPass(array('required' => false)),
      'material'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'oxidationcorrosion'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'pack_deformation'                => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'noise_reduction'                 => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'tape_type'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'thin_tape'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'slow_speed'                      => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'sound_field'                     => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'soft_binder_syndrome'            => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'gauge'                           => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'color'                           => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'colorfade'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'soundtrackformat'                => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'substrate'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'strongodor'                      => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'vinegarodor'                     => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'adstriplevel'                    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'shrinkage'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'levelofshrinkage'                => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'rust'                            => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'discoloration'                   => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'surfaceblisteringbubbling'       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'thintape'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      '1993orearlier'                   => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'datagradetape'                   => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'longplay32k96k'                  => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'corrosionrustoxidation'          => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'composition'                     => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'nonstandardbrand'                => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'trackconfiguration'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'tapethickness'                   => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'speed'                           => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'softbindersyndrome'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'materialsbreakdown'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'physicaldamage'                  => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'delamination'                    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'plasticizerexudation'            => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'recordinglayer'                  => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'recordingspeed'                  => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'cylindertype'                    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'reflectivelayer'                 => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'datalayer'                       => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'opticaldisctype'                 => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'format'                          => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'recordingstandard'               => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'publicationyear'                 => new sfValidatorDateRange(array('required' => false, 'from_date' => new sfValidatorDate(array('required' => false)), 'to_date' => new sfValidatorDateTime(array('required' => false)))),
      'capacitylayers'                  => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'codec'                           => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'datarate'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'sheddingsoftbinder'              => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'formatversion'                   => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'oxide'                           => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'bindersystem'                    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'reelsize'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'whiteresidue'                    => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'size'                            => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'formattypedvideorecordingformat' => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'bitrate'                         => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'scanning'                        => new sfValidatorSchemaFilter('text', new sfValidatorInteger(array('required' => false))),
      'created_at'                      => new sfValidatorDateRange(array('required' => false, 'from_date' => new sfValidatorDateTime(array('required' => false, 'datetime_output' => 'Y-m-d 00:00:00')), 'to_date' => new sfValidatorDateTime(array('required' => false, 'datetime_output' => 'Y-m-d 23:59:59')))),
      'updated_at'                      => new sfValidatorDateRange(array('required' => false, 'from_date' => new sfValidatorDateTime(array('required' => false, 'datetime_output' => 'Y-m-d 00:00:00')), 'to_date' => new sfValidatorDateTime(array('required' => false, 'datetime_output' => 'Y-m-d 23:59:59')))),
    ));

    $this->widgetSchema->setNameFormat('pressed78_rpm_disc_filters[%s]');

    $this->errorSchema = new sfValidatorErrorSchema($this->validatorSchema);

    $this->setupInheritance();

    parent::setup();
  }

  public function getModelName()
  {
    return 'Pressed78RPMDisc';
  }

  public function getFields()
  {
    return array(
      'id'                              => 'Number',
      'quantity'                        => 'Number',
      'generation'                      => 'Number',
      'year_recorded'                   => 'Text',
      'copies'                          => 'Number',
      'stock_brand'                     => 'Text',
      'off_brand'                       => 'Number',
      'fungus'                          => 'Number',
      'other_contaminants'              => 'Number',
      'duration'                        => 'Number',
      'duration_type'                   => 'Text',
      'type'                            => 'Text',
      'material'                        => 'Number',
      'oxidationcorrosion'              => 'Number',
      'pack_deformation'                => 'Number',
      'noise_reduction'                 => 'Number',
      'tape_type'                       => 'Number',
      'thin_tape'                       => 'Number',
      'slow_speed'                      => 'Number',
      'sound_field'                     => 'Number',
      'soft_binder_syndrome'            => 'Number',
      'gauge'                           => 'Number',
      'color'                           => 'Number',
      'colorfade'                       => 'Number',
      'soundtrackformat'                => 'Number',
      'substrate'                       => 'Number',
      'strongodor'                      => 'Number',
      'vinegarodor'                     => 'Number',
      'adstriplevel'                    => 'Number',
      'shrinkage'                       => 'Number',
      'levelofshrinkage'                => 'Number',
      'rust'                            => 'Number',
      'discoloration'                   => 'Number',
      'surfaceblisteringbubbling'       => 'Number',
      'thintape'                        => 'Number',
      '1993orearlier'                   => 'Number',
      'datagradetape'                   => 'Number',
      'longplay32k96k'                  => 'Number',
      'corrosionrustoxidation'          => 'Number',
      'composition'                     => 'Number',
      'nonstandardbrand'                => 'Number',
      'trackconfiguration'              => 'Number',
      'tapethickness'                   => 'Number',
      'speed'                           => 'Number',
      'softbindersyndrome'              => 'Number',
      'materialsbreakdown'              => 'Number',
      'physicaldamage'                  => 'Number',
      'delamination'                    => 'Number',
      'plasticizerexudation'            => 'Number',
      'recordinglayer'                  => 'Number',
      'recordingspeed'                  => 'Number',
      'cylindertype'                    => 'Number',
      'reflectivelayer'                 => 'Number',
      'datalayer'                       => 'Number',
      'opticaldisctype'                 => 'Number',
      'format'                          => 'Number',
      'recordingstandard'               => 'Number',
      'publicationyear'                 => 'Date',
      'capacitylayers'                  => 'Number',
      'codec'                           => 'Number',
      'datarate'                        => 'Number',
      'sheddingsoftbinder'              => 'Number',
      'formatversion'                   => 'Number',
      'oxide'                           => 'Number',
      'bindersystem'                    => 'Number',
      'reelsize'                        => 'Number',
      'whiteresidue'                    => 'Number',
      'size'                            => 'Number',
      'formattypedvideorecordingformat' => 'Number',
      'bitrate'                         => 'Number',
      'scanning'                        => 'Number',
      'created_at'                      => 'Date',
      'updated_at'                      => 'Date',
    );
  }
}


text:
package de.unifreiburg.cs.proglang.jgs.typing;

import de.unifreiburg.cs.proglang.jgs.constraints.CTypes;
import de.unifreiburg.cs.proglang.jgs.constraints.Constraint;
import de.unifreiburg.cs.proglang.jgs.constraints.Constraints;
import de.unifreiburg.cs.proglang.jgs.constraints.TypeVars;
import de.unifreiburg.cs.proglang.jgs.constraints.TypeVars.TypeVar;
import de.unifreiburg.cs.proglang.jgs.instrumentation.Var;
import scala.Option;

import java.util.*;

/**
 * Environments: immutable maps from Locals to type variables.
 *
 * @author fennell
 *
 */
public class Environment {

    public static class JoinResult<Level> {
        public final List<Constraint<Level>> constraints;
        public final Environment env;
        private final Map<TypeVar, TypeVar> translations;

        public JoinResult(List<Constraint<Level>> constraints, Environment env, Map<TypeVar, TypeVar> translations) {
            this.constraints = constraints;
            this.env = env;
            this.translations = translations;
        }

        public TypeVar translate(TypeVar v) {
            if (this.translations.containsKey(v)) {
                return this.translations.get(v);
            } else {
                return v;
            }
        }

    }

    /**
     * The domain of environments "Var"s which are soot.Local and soot.jimple.ThisRef
     * (and perhaps soot.jimple.ParameterRef). (Hopefully) Their only purpose is to
     * have an identity
     */
    private final Map<Var<?>, TypeVar> env;

    /**
     * Joint two environments. Returns a JoinResult that
     * contains the joined environment, the constraints that force
     * unification of local variables, and a translation map that records
     * which original variables were replaced by joins.
     */
    public static <Level> JoinResult<Level> join(TypeVars tvars, Environment r1, Environment r2) {
        Map<Var<?>, TypeVar> joinedEnv = new HashMap<>();
        Map<TypeVar, TypeVar> translations = new HashMap<>();
        List<Constraint<Level>> cs = new LinkedList<>();
        for (Map.Entry<Var<?>, TypeVar> e : r1.env.entrySet()) {
            Var<?> k = e.getKey();
            TypeVar v1 = e.getValue();
            if (r2.env.containsKey(k)) {
                TypeVar v2 = r2.get(k);
                if (!v1.equals(v2)) {
                    TypeVar vNew = tvars.join(v1, v2);
                    cs.add(Constraints.<Level>le(CTypes.<Level>variable(v1), CTypes.<Level>variable(vNew)));
                    cs.add(Constraints.<Level>le(CTypes.<Level>variable(v2), CTypes.<Level>variable(vNew)));
                    joinedEnv.put(k, vNew);
                    translations.put(v1, vNew);
                    translations.put(v2, vNew);
                } else {
                    joinedEnv.put(k, v1);
                }
            } else {
                joinedEnv.put(k, v1);
            }
        }
        for (Map.Entry<Var<?>, TypeVar> e : r2.env.entrySet()) {
            Var<?> k = e.getKey();
            if (!r1.env.containsKey(k)) {
                joinedEnv.put(k, e.getValue());
            }
        }
        return new JoinResult<>(cs, Environments.fromMap(joinedEnv), translations);
    }

    public Environment(Map<Var<?>, TypeVar> env) {
        this.env = new HashMap<>(env);
    }

    private Environment(Map<Var<?>, TypeVar> env, Map<Var<?>, TypeVar> newEntries) {
        this(env);
        this.env.putAll(newEntries);
    }

    public Environment add(Var<?> k, TypeVar v) {
        return new Environment(this.env, Collections.<Var<?>, TypeVar>singletonMap(k, v));
    }

    public Environment add(Environment other) {
        return new Environment(this.env, other.env);
    }

    public TypeVar get(Var<?> local) {
        Option<TypeVar> mv = this.tryGet(local);
        if (mv.isEmpty()) {
            throw new NoSuchElementException(local.toString());
        }
        return mv.get();
    }

    public Option<TypeVar> tryGet(Var<?> local) {
        return Option.apply(this.env.get(local));
    }

    public Map<Var<?>, TypeVar> getMap() {
        return Collections.unmodifiableMap(this.env);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Environment that = (Environment) o;

        return !(env != null ? !env.equals(that.env) : that.env != null);

    }

    @Override
    public int hashCode() {
        return env != null ? env.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "Environment [env=" + env + "]";
    }

}


text:
package com.google.common.base;

import static com.google.common.base.Preconditions.checkPositionIndexes;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;

import javax.annotation.CheckReturnValue;

/**
 * Low-level, high-performance utility methods related to the {@linkplain Charsets#UTF_8 UTF-8}
 * character encoding. UTF-8 is defined in section D92 of
 * The Unicode Standard Core
 * Specification, Chapter 3.
 *
 *
The variant of UTF-8 implemented by this class is the restricted definition of UTF-8
 * introduced in Unicode 3.1. One implication of this is that it rejects
 * "non-shortest form" byte
 * sequences, even though the JDK decoder may accept them.
 *
 * @author Martin Buchholz
 * @author Clément Roux
 * @since 16.0
 */
@Beta
@GwtCompatible
public final class Utf8 {
  /**
   * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string,
   * this method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in
   * both time and space.
   *
   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
   *     surrogates)
   */
  @CheckReturnValue
  public static int encodedLength(CharSequence sequence) {
    // Warning to maintainers: this implementation is highly optimized.
    int utf16Length = sequence.length();
    int utf8Length = utf16Length;
    int i = 0;

    // This loop optimizes for pure ASCII.
    while (i < utf16Length && sequence.charAt(i) < 0x80) {
      i++;
    }

    // This loop optimizes for chars less than 0x800.
    for (; i < utf16Length; i++) {
      char c = sequence.charAt(i);
      if (c < 0x800) {
        utf8Length += ((0x7f - c) >>> 31); // branch free!
      } else {
        utf8Length += encodedLengthGeneral(sequence, i);
        break;
      }
    }

    if (utf8Length < utf16Length) {
      // Necessary and sufficient condition for overflow because of maximum 3x expansion
      throw new IllegalArgumentException(
          "UTF-8 length does not fit in int: " + (utf8Length + (1L << 32)));
    }
    return utf8Length;
  }

  private static int encodedLengthGeneral(CharSequence sequence, int start) {
    int utf16Length = sequence.length();
    int utf8Length = 0;
    for (int i = start; i < utf16Length; i++) {
      char c = sequence.charAt(i);
      if (c < 0x800) {
        utf8Length += (0x7f - c) >>> 31; // branch free!
      } else {
        utf8Length += 2;
        // jdk7+: if (Character.isSurrogate(c)) {
        if (Character.MIN_SURROGATE <= c && c <= Character.MAX_SURROGATE) {
          // Check that we have a well-formed surrogate pair.
          int cp = Character.codePointAt(sequence, i);
          if (cp < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
            throw new IllegalArgumentException("Unpaired surrogate at index " + i);
          }
          i++;
        }
      }
    }
    return utf8Length;
  }

  /**
   * Returns {@code true} if {@code bytes} is a well-formed UTF-8 byte sequence according to
   * Unicode 6.0. Note that this is a stronger criterion than simply whether the bytes can be
   * decoded. For example, some versions of the JDK decoder will accept "non-shortest form" byte
   * sequences, but encoding never reproduces these. Such byte sequences are not considered
   * well-formed.
   *
   *
This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  @CheckReturnValue
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**
   * Returns whether the given byte array slice is a well-formed UTF-8 byte sequence, as defined by
   * {@link #isWellFormed(byte[])}. Note that this can be false even when {@code
   * isWellFormed(bytes)} is true.
   *
   * @param bytes the input buffer
   * @param off the offset in the buffer of the first byte to read
   * @param len the number of bytes to read from the buffer
   */
  @CheckReturnValue
  public static boolean isWellFormed(byte[] bytes, int off, int len) {
    int end = off + len;
    checkPositionIndexes(off, end, bytes.length);
    // Look for the first non-ASCII character.
    for (int i = off; i < end; i++) {
      if (bytes[i] < 0) {
        return isWellFormedSlowPath(bytes, i, end);
      }
    }
    return true;
  }

  private static boolean isWellFormedSlowPath(byte[] bytes, int off, int end) {
    int index = off;
    while (true) {
      int byte1;

      // Optimize for interior runs of ASCII bytes.
      do {
        if (index >= end) {
          return true;
        }
      } while ((byte1 = bytes[index++]) >= 0);

      if (byte1 < (byte) 0xE0) {
        // Two-byte form.
        if (index == end) {
          return false;
        }
        // Simultaneously check for illegal trailing-byte in leading position
        // and overlong 2-byte form.
        if (byte1 < (byte) 0xC2 || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else if (byte1 < (byte) 0xF0) {
        // Three-byte form.
        if (index + 1 >= end) {
          return false;
        }
        int byte2 = bytes[index++];
        if (byte2 > (byte) 0xBF
            // Overlong? 5 most significant bits must not all be zero.
            || (byte1 == (byte) 0xE0 && byte2 < (byte) 0xA0)
            // Check for illegal surrogate codepoints.
            || (byte1 == (byte) 0xED && (byte) 0xA0 <= byte2)
            // Third byte trailing-byte test.
            || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      } else {
        // Four-byte form.
        if (index + 2 >= end) {
          return false;
        }
        int byte2 = bytes[index++];
        if (byte2 > (byte) 0xBF
            // Check that 1 <= plane <= 16. Tricky optimized form of:
            // if (byte1 > (byte) 0xF4
            //     || byte1 == (byte) 0xF0 && byte2 < (byte) 0x90
            //     || byte1 == (byte) 0xF4 && byte2 > (byte) 0x8F)
            || (((byte1 << 28) + (byte2 - (byte) 0x90)) >> 30) != 0
            // Third byte trailing-byte test
            || bytes[index++] > (byte) 0xBF
            // Fourth byte trailing-byte test
            || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      }
    }
  }

  private Utf8() {}
}


text:
<?php

/**
 * Drago Extension
 * Package built on Nette Framework
 */

declare(strict_types=1);

namespace Drago\Localization\DI;

use Drago\Localization\Translator;
use Nette\DI\CompilerExtension;

/**
 * Register services.
 */
class TranslatorExtension extends CompilerExtension
{
	public function __construct(
		public string $translateDir,
	) {
	}

	public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();
		$builder->addDefinition($this->prefix('translator'))
			->setFactory(Translator::class, [$this->translateDir]);
	}
}


text:
class CatPoliesController < ApplicationController
  before_action :set_cat_poly, only: [:show, :edit, :update, :destroy]

  # GET /cat_polies
  # GET /cat_polies.json
  def index
    @cat_polies = CatPoly.all
  end

  # GET /cat_polies/1
  # GET /cat_polies/1.json
  def show
  end

  # GET /cat_polies/new
  def new
    @cat_poly = CatPoly.new
  end

  # GET /cat_polies/1/edit
  def edit
  end

  # POST /cat_polies
  # POST /cat_polies.json
  def create
    @cat_poly = CatPoly.new(cat_poly_params)

    respond_to do |format|
      if @cat_poly.save
        format.html { redirect_to @cat_poly, notice: 'Cat poly was successfully created.' }
        format.json { render :show, status: :created, location: @cat_poly }
      else
        format.html { render :new }
        format.json { render json: @cat_poly.errors, status: :unprocessable_entity }
      end
    end
  end

  # PATCH/PUT /cat_polies/1
  # PATCH/PUT /cat_polies/1.json
  def update
    respond_to do |format|
      if @cat_poly.update(cat_poly_params)
        format.html { redirect_to @cat_poly, notice: 'Cat poly was successfully updated.' }
        format.json { render :show, status: :ok, location: @cat_poly }
      else
        format.html { render :edit }
        format.json { render json: @cat_poly.errors, status: :unprocessable_entity }
      end
    end
  end

  # DELETE /cat_polies/1
  # DELETE /cat_polies/1.json
  def destroy
    @cat_poly.destroy
    respond_to do |format|
      format.html { redirect_to cat_polies_url, notice: 'Cat poly was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  private
    # Use callbacks to share common setup or constraints between actions.
    def set_cat_poly
      @cat_poly = CatPoly.find(params[:id])
    end

    # Never trust parameters from the scary internet, only allow the white list through.
    def cat_poly_params
      params.require(:cat_poly).permit(:dog_poly, :fish_poly)
    end
end


text:
#pragma once

#include "il2cpp-config.h"

#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif

#include <stdint.h>

// System.Byte[]
struct ByteU5BU5D_t4260760469;
// System.Collections.ArrayList
struct ArrayList_t3948406897;
// Mono.Security.X509.X509CertificateCollection
struct X509CertificateCollection_t4135795358;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t1757673517;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32>
struct Dictionary_2_t1974256870;

#include "mscorlib_System_Object4170816371.h"

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif

// Mono.Security.X509.PKCS12
struct  PKCS12_t1158032325  : public Il2CppObject
{
public:
	// System.Byte[] Mono.Security.X509.PKCS12::_password
	ByteU5BU5D_t4260760469* ____password_1;
	// System.Collections.ArrayList Mono.Security.X509.PKCS12::_keyBags
	ArrayList_t3948406897 * ____keyBags_2;
	// System.Collections.ArrayList Mono.Security.X509.PKCS12::_secretBags
	ArrayList_t3948406897 * ____secretBags_3;
	// Mono.Security.X509.X509CertificateCollection Mono.Security.X509.PKCS12::_certs
	X509CertificateCollection_t4135795358 * ____certs_4;
	// System.Boolean Mono.Security.X509.PKCS12::_keyBagsChanged
	bool ____keyBagsChanged_5;
	// System.Boolean Mono.Security.X509.PKCS12::_secretBagsChanged
	bool ____secretBagsChanged_6;
	// System.Boolean Mono.Security.X509.PKCS12::_certsChanged
	bool ____certsChanged_7;
	// System.Int32 Mono.Security.X509.PKCS12::_iterations
	int32_t ____iterations_8;
	// System.Collections.ArrayList Mono.Security.X509.PKCS12::_safeBags
	ArrayList_t3948406897 * ____safeBags_9;
	// System.Security.Cryptography.RandomNumberGenerator Mono.Security.X509.PKCS12::_rng
	RandomNumberGenerator_t1757673517 * ____rng_10;

public:
	inline static int32_t get_offset_of__password_1() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____password_1)); }
	inline ByteU5BU5D_t4260760469* get__password_1() const { return ____password_1; }
	inline ByteU5BU5D_t4260760469** get_address_of__password_1() { return &____password_1; }
	inline void set__password_1(ByteU5BU5D_t4260760469* value)
	{
		____password_1 = value;
		Il2CppCodeGenWriteBarrier(&____password_1, value);
	}

	inline static int32_t get_offset_of__keyBags_2() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____keyBags_2)); }
	inline ArrayList_t3948406897 * get__keyBags_2() const { return ____keyBags_2; }
	inline ArrayList_t3948406897 ** get_address_of__keyBags_2() { return &____keyBags_2; }
	inline void set__keyBags_2(ArrayList_t3948406897 * value)
	{
		____keyBags_2 = value;
		Il2CppCodeGenWriteBarrier(&____keyBags_2, value);
	}

	inline static int32_t get_offset_of__secretBags_3() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____secretBags_3)); }
	inline ArrayList_t3948406897 * get__secretBags_3() const { return ____secretBags_3; }
	inline ArrayList_t3948406897 ** get_address_of__secretBags_3() { return &____secretBags_3; }
	inline void set__secretBags_3(ArrayList_t3948406897 * value)
	{
		____secretBags_3 = value;
		Il2CppCodeGenWriteBarrier(&____secretBags_3, value);
	}

	inline static int32_t get_offset_of__certs_4() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____certs_4)); }
	inline X509CertificateCollection_t4135795358 * get__certs_4() const { return ____certs_4; }
	inline X509CertificateCollection_t4135795358 ** get_address_of__certs_4() { return &____certs_4; }
	inline void set__certs_4(X509CertificateCollection_t4135795358 * value)
	{
		____certs_4 = value;
		Il2CppCodeGenWriteBarrier(&____certs_4, value);
	}

	inline static int32_t get_offset_of__keyBagsChanged_5() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____keyBagsChanged_5)); }
	inline bool get__keyBagsChanged_5() const { return ____keyBagsChanged_5; }
	inline bool* get_address_of__keyBagsChanged_5() { return &____keyBagsChanged_5; }
	inline void set__keyBagsChanged_5(bool value)
	{
		____keyBagsChanged_5 = value;
	}

	inline static int32_t get_offset_of__secretBagsChanged_6() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____secretBagsChanged_6)); }
	inline bool get__secretBagsChanged_6() const { return ____secretBagsChanged_6; }
	inline bool* get_address_of__secretBagsChanged_6() { return &____secretBagsChanged_6; }
	inline void set__secretBagsChanged_6(bool value)
	{
		____secretBagsChanged_6 = value;
	}

	inline static int32_t get_offset_of__certsChanged_7() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____certsChanged_7)); }
	inline bool get__certsChanged_7() const { return ____certsChanged_7; }
	inline bool* get_address_of__certsChanged_7() { return &____certsChanged_7; }
	inline void set__certsChanged_7(bool value)
	{
		____certsChanged_7 = value;
	}

	inline static int32_t get_offset_of__iterations_8() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____iterations_8)); }
	inline int32_t get__iterations_8() const { return ____iterations_8; }
	inline int32_t* get_address_of__iterations_8() { return &____iterations_8; }
	inline void set__iterations_8(int32_t value)
	{
		____iterations_8 = value;
	}

	inline static int32_t get_offset_of__safeBags_9() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____safeBags_9)); }
	inline ArrayList_t3948406897 * get__safeBags_9() const { return ____safeBags_9; }
	inline ArrayList_t3948406897 ** get_address_of__safeBags_9() { return &____safeBags_9; }
	inline void set__safeBags_9(ArrayList_t3948406897 * value)
	{
		____safeBags_9 = value;
		Il2CppCodeGenWriteBarrier(&____safeBags_9, value);
	}

	inline static int32_t get_offset_of__rng_10() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325, ____rng_10)); }
	inline RandomNumberGenerator_t1757673517 * get__rng_10() const { return ____rng_10; }
	inline RandomNumberGenerator_t1757673517 ** get_address_of__rng_10() { return &____rng_10; }
	inline void set__rng_10(RandomNumberGenerator_t1757673517 * value)
	{
		____rng_10 = value;
		Il2CppCodeGenWriteBarrier(&____rng_10, value);
	}
};

struct PKCS12_t1158032325_StaticFields
{
public:
	// System.Int32 Mono.Security.X509.PKCS12::recommendedIterationCount
	int32_t ___recommendedIterationCount_0;
	// System.Int32 Mono.Security.X509.PKCS12::password_max_length
	int32_t ___password_max_length_11;
	// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map5
	Dictionary_2_t1974256870 * ___U3CU3Ef__switchU24map5_12;
	// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map6
	Dictionary_2_t1974256870 * ___U3CU3Ef__switchU24map6_13;
	// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map7
	Dictionary_2_t1974256870 * ___U3CU3Ef__switchU24map7_14;
	// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$map8
	Dictionary_2_t1974256870 * ___U3CU3Ef__switchU24map8_15;
	// System.Collections.Generic.Dictionary`2<System.String,System.Int32> Mono.Security.X509.PKCS12::<>f__switch$mapC
	Dictionary_2_t1974256870 * ___U3CU3Ef__switchU24mapC_16;

public:
	inline static int32_t get_offset_of_recommendedIterationCount_0() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___recommendedIterationCount_0)); }
	inline int32_t get_recommendedIterationCount_0() const { return ___recommendedIterationCount_0; }
	inline int32_t* get_address_of_recommendedIterationCount_0() { return &___recommendedIterationCount_0; }
	inline void set_recommendedIterationCount_0(int32_t value)
	{
		___recommendedIterationCount_0 = value;
	}

	inline static int32_t get_offset_of_password_max_length_11() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___password_max_length_11)); }
	inline int32_t get_password_max_length_11() const { return ___password_max_length_11; }
	inline int32_t* get_address_of_password_max_length_11() { return &___password_max_length_11; }
	inline void set_password_max_length_11(int32_t value)
	{
		___password_max_length_11 = value;
	}

	inline static int32_t get_offset_of_U3CU3Ef__switchU24map5_12() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___U3CU3Ef__switchU24map5_12)); }
	inline Dictionary_2_t1974256870 * get_U3CU3Ef__switchU24map5_12() const { return ___U3CU3Ef__switchU24map5_12; }
	inline Dictionary_2_t1974256870 ** get_address_of_U3CU3Ef__switchU24map5_12() { return &___U3CU3Ef__switchU24map5_12; }
	inline void set_U3CU3Ef__switchU24map5_12(Dictionary_2_t1974256870 * value)
	{
		___U3CU3Ef__switchU24map5_12 = value;
		Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map5_12, value);
	}

	inline static int32_t get_offset_of_U3CU3Ef__switchU24map6_13() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___U3CU3Ef__switchU24map6_13)); }
	inline Dictionary_2_t1974256870 * get_U3CU3Ef__switchU24map6_13() const { return ___U3CU3Ef__switchU24map6_13; }
	inline Dictionary_2_t1974256870 ** get_address_of_U3CU3Ef__switchU24map6_13() { return &___U3CU3Ef__switchU24map6_13; }
	inline void set_U3CU3Ef__switchU24map6_13(Dictionary_2_t1974256870 * value)
	{
		___U3CU3Ef__switchU24map6_13 = value;
		Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map6_13, value);
	}

	inline static int32_t get_offset_of_U3CU3Ef__switchU24map7_14() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___U3CU3Ef__switchU24map7_14)); }
	inline Dictionary_2_t1974256870 * get_U3CU3Ef__switchU24map7_14() const { return ___U3CU3Ef__switchU24map7_14; }
	inline Dictionary_2_t1974256870 ** get_address_of_U3CU3Ef__switchU24map7_14() { return &___U3CU3Ef__switchU24map7_14; }
	inline void set_U3CU3Ef__switchU24map7_14(Dictionary_2_t1974256870 * value)
	{
		___U3CU3Ef__switchU24map7_14 = value;
		Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map7_14, value);
	}

	inline static int32_t get_offset_of_U3CU3Ef__switchU24map8_15() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___U3CU3Ef__switchU24map8_15)); }
	inline Dictionary_2_t1974256870 * get_U3CU3Ef__switchU24map8_15() const { return ___U3CU3Ef__switchU24map8_15; }
	inline Dictionary_2_t1974256870 ** get_address_of_U3CU3Ef__switchU24map8_15() { return &___U3CU3Ef__switchU24map8_15; }
	inline void set_U3CU3Ef__switchU24map8_15(Dictionary_2_t1974256870 * value)
	{
		___U3CU3Ef__switchU24map8_15 = value;
		Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24map8_15, value);
	}

	inline static int32_t get_offset_of_U3CU3Ef__switchU24mapC_16() { return static_cast<int32_t>(offsetof(PKCS12_t1158032325_StaticFields, ___U3CU3Ef__switchU24mapC_16)); }
	inline Dictionary_2_t1974256870 * get_U3CU3Ef__switchU24mapC_16() const { return ___U3CU3Ef__switchU24mapC_16; }
	inline Dictionary_2_t1974256870 ** get_address_of_U3CU3Ef__switchU24mapC_16() { return &___U3CU3Ef__switchU24mapC_16; }
	inline void set_U3CU3Ef__switchU24mapC_16(Dictionary_2_t1974256870 * value)
	{
		___U3CU3Ef__switchU24mapC_16 = value;
		Il2CppCodeGenWriteBarrier(&___U3CU3Ef__switchU24mapC_16, value);
	}
};

#ifdef __clang__
#pragma clang diagnostic pop
#endif


text:
package com.intellij.ide.actions;

import com.intellij.ide.BrowserUtil;
import com.intellij.ide.FeedbackDescriptionProvider;
import com.intellij.ide.feedback.FeedbackForm;
import com.intellij.idea.ActionsBundle;
import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.application.ApplicationInfo;
import com.intellij.openapi.application.ex.ApplicationInfoEx;
import com.intellij.openapi.application.impl.ApplicationInfoImpl;
import com.intellij.openapi.application.impl.ZenDeskForm;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.project.DumbAware;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.util.registry.Registry;
import com.intellij.ui.LicensingFacade;
import com.intellij.ui.scale.JBUIScale;
import com.intellij.util.io.URLUtil;
import com.intellij.util.ui.UIUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.awt.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SendFeedbackAction extends AnAction implements DumbAware {
  @Override
  public void update(@NotNull AnActionEvent e) {
    ApplicationInfoEx info = ApplicationInfoEx.getInstanceEx();
    boolean isSupportedOS = SystemInfo.isMac || SystemInfo.isLinux || SystemInfo.isWindows;
    if (info != null && info.getFeedbackUrl() != null && isSupportedOS) {
      String feedbackSite = getFeedbackHost(info.getFeedbackUrl(), info.getCompanyName());
      e.getPresentation().setDescription(ActionsBundle.messagePointer("action.SendFeedback.detailed.description", feedbackSite));
      e.getPresentation().setEnabledAndVisible(true);
    }
    else {
      e.getPresentation().setEnabledAndVisible(false);
    }
  }

  private static String getFeedbackHost(String feedbackUrl, String companyName) {
    Pattern uriPattern = Pattern.compile("[^:/?#]+://(?:www\\.)?([^/?#]*).*", Pattern.DOTALL);
    Matcher matcher = uriPattern.matcher(feedbackUrl);
    return matcher.matches() ? matcher.group(1) : companyName;
  }

  @Override
  public void actionPerformed(@NotNull AnActionEvent e) {
    ZenDeskForm feedbackForm = ((ApplicationInfoImpl)ApplicationInfo.getInstance()).getFeedbackForm();
    if (Registry.is("ide.in.product.feedback") && feedbackForm != null) {
      new FeedbackForm(e.getProject(), feedbackForm, false).show();
    }
    else {
      submit(e.getProject());
    }
  }

  public static void submit(@Nullable Project project) {
    submit(project, ApplicationInfoEx.getInstanceEx().getFeedbackUrl(), getDescription(project));
  }

  public static void submit(@Nullable Project project, @NotNull String description) {
    submit(project, ApplicationInfoEx.getInstanceEx().getFeedbackUrl(), description);
  }

  public static void submit(@Nullable Project project, @NotNull String urlTemplate, @NotNull String description) {
    ApplicationInfoEx appInfo = ApplicationInfoEx.getInstanceEx();
    boolean eap = appInfo.isEAP();
    LicensingFacade la = LicensingFacade.getInstance();
    String url = urlTemplate
      .replace("$BUILD", URLUtil.encodeURIComponent(eap ? appInfo.getBuild().asStringWithoutProductCode() : appInfo.getBuild().asString()))
      .replace("$TIMEZONE", URLUtil.encodeURIComponent(System.getProperty("user.timezone", "")))
      .replace("$VERSION", URLUtil.encodeURIComponent(appInfo.getFullVersion()))
      .replace("$EVAL", URLUtil.encodeURIComponent(la != null && la.isEvaluationLicense() ? "true" : "false"))
      .replace("$DESCR", URLUtil.encodeURIComponent(description));
    BrowserUtil.browse(url, project);
  }

  public static @NotNull String getDescription(@Nullable Project project) {
    @NonNls StringBuilder sb = new StringBuilder("\n\n");
    sb.append(ApplicationInfoEx.getInstanceEx().getBuild().asString()).append(", ");
    String javaVersion = System.getProperty("java.runtime.version", System.getProperty("java.version", "unknown"));
    sb.append("JRE ");
    sb.append(javaVersion);
    String archDataModel = System.getProperty("sun.arch.data.model");
    if (archDataModel != null) {
      sb.append("x").append(archDataModel);
    }
    String javaVendor = System.getProperty("java.vm.vendor");
    if (javaVendor != null) {
      sb.append(" ").append(javaVendor);
    }
    sb.append(", OS ").append(System.getProperty("os.name"));
    String osArch = System.getProperty("os.arch");
    if (osArch != null) {
      sb.append("(").append(osArch).append(")");
    }

    String osVersion = System.getProperty("os.version");
    String osPatchLevel = System.getProperty("sun.os.patch.level");
    if (osVersion != null) {
      sb.append(" v").append(osVersion);
      if (osPatchLevel != null && !"unknown".equals(osPatchLevel)) {
        sb.append(" ").append(osPatchLevel);
      }
    }
    if (!GraphicsEnvironment.isHeadless()) {
      sb.append(", screens ");
      GraphicsDevice[] devices = GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices();
      for (int i = 0; i < devices.length; i++) {
        if (i > 0) sb.append(", ");
        GraphicsDevice device = devices[i];
        DisplayMode displayMode = device.getDisplayMode();
        float scale = JBUIScale.sysScale(device.getDefaultConfiguration());
        sb.append(displayMode.getWidth() * scale).append("x").append(displayMode.getHeight() * scale);
      }
      if (UIUtil.isRetina()) {
        sb.append(SystemInfo.isMac ? "; Retina" : "; HiDPI");
      }
    }
    for (FeedbackDescriptionProvider ext : EP_NAME.getExtensions()) {
      String pluginDescription = ext.getDescription(project);
      if (pluginDescription != null && pluginDescription.length() > 0) {
        sb.append("\n").append(pluginDescription);
      }
    }
    return sb.toString();
  }

  private static final ExtensionPointName<FeedbackDescriptionProvider> EP_NAME = new ExtensionPointName<>("com.intellij.feedbackDescriptionProvider");
}


text:
namespace bluez {

BluetoothGattCharacteristicDelegateWrapper::
    BluetoothGattCharacteristicDelegateWrapper(
        BluetoothLocalGattServiceBlueZ* service,
        BluetoothLocalGattCharacteristicBlueZ* characteristic)
    : BluetoothGattAttributeValueDelegate(service),
      characteristic_(characteristic) {}

void BluetoothGattCharacteristicDelegateWrapper::GetValue(
    const dbus::ObjectPath& device_path,
    const device::BluetoothLocalGattService::Delegate::ValueCallback& callback,
    const device::BluetoothLocalGattService::Delegate::ErrorCallback&
        error_callback) {
  service()->GetDelegate()->OnCharacteristicReadRequest(
      GetDeviceWithPath(device_path), characteristic_, 0, callback,
      error_callback);
}

void BluetoothGattCharacteristicDelegateWrapper::SetValue(
    const dbus::ObjectPath& device_path,
    const std::vector<uint8_t>& value,
    const base::Closure& callback,
    const device::BluetoothLocalGattService::Delegate::ErrorCallback&
        error_callback) {
  service()->GetDelegate()->OnCharacteristicWriteRequest(
      GetDeviceWithPath(device_path), characteristic_, value, 0, callback,
      error_callback);
}

void BluetoothGattCharacteristicDelegateWrapper::StartNotifications() {
  service()->GetDelegate()->OnNotificationsStart(nullptr, characteristic_);
}

void BluetoothGattCharacteristicDelegateWrapper::StopNotifications() {
  service()->GetDelegate()->OnNotificationsStop(nullptr, characteristic_);
}

}  // namespace bluez


text:
// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated via go generate.
// DO NOT UPDATE MANUALLY

/*
Command cluster_agent supports interactions with a cluster agent.

Usage:
   cluster_agent [flags] <command>

The cluster_agent commands are:
   new           Requests a new secret.
   forget        Forgets an existing secret and its associated blessings.
   seekblessings Retrieves all the blessings associated with a particular
                 secret.
   help          Display help for commands or topics

The cluster_agent flags are:
 -agent=
   The name or address of the cluster agent server.

The global flags are:
 -alsologtostderr=true
   log to standard error as well as files
 -log_backtrace_at=:0
   when logging hits line file:N, emit a stack trace
 -log_dir=
   if non-empty, write log files to this directory
 -logtostderr=false
   log to standard error instead of files
 -max_stack_buf_size=4292608
   max size in bytes of the buffer to use for logging stack traces
 -metadata=<just specify -metadata to activate>
   Displays metadata for the program and exits.
 -stderrthreshold=2
   logs at or above this threshold go to stderr
 -time=false
   Dump timing information to stderr before exiting the program.
 -v=0
   log level for V logs
 -v23.credentials=
   directory to use for storing security credentials
 -v23.i18n-catalogue=
   18n catalogue files to load, comma separated
 -v23.namespace.root=[/(dev.v.io:r:vprod:service:mounttabled)@ns.dev.v.io:8101]
   local namespace root; can be repeated to provided multiple roots
 -v23.proxy=
   object name of proxy service to use to export services across network
   boundaries
 -v23.tcp.address=
   address to listen on
 -v23.tcp.protocol=wsh
   protocol to listen with
 -v23.vtrace.cache-size=1024
   The number of vtrace traces to store in memory.
 -v23.vtrace.collect-regexp=
   Spans and annotations that match this regular expression will trigger trace
   collection.
 -v23.vtrace.dump-on-shutdown=true
   If true, dump all stored traces on runtime shutdown.
 -v23.vtrace.sample-rate=0
   Rate (from 0.0 to 1.0) to sample vtrace traces.
 -v23.vtrace.v=0
   The verbosity level of the log messages to be captured in traces
 -vmodule=
   comma-separated list of globpattern=N settings for filename-filtered logging
   (without the .go suffix).  E.g. foo/bar/baz.go is matched by patterns baz or
   *az or b* but not by bar/baz or baz.go or az or b.*
 -vpath=
   comma-separated list of regexppattern=N settings for file pathname-filtered
   logging (without the .go suffix).  E.g. foo/bar/baz.go is matched by patterns
   foo/bar/baz or fo.*az or oo/ba or b.z but not by foo/bar/baz.go or fo*az

Cluster_agent new

Requests a new secret.

Usage:
   cluster_agent new [flags] <extension>

<extension> is the blessing name extension to associate with the new secret.

The cluster_agent new flags are:
 -base64=false
   If true, the secret is base64-encoded

 -agent=
   The name or address of the cluster agent server.

Cluster_agent forget

Forgets an existing secret and its associated blessings.

Usage:
   cluster_agent forget [flags] <secret>

<secret> is the secret to forget.

The cluster_agent forget flags are:
 -agent=
   The name or address of the cluster agent server.

Cluster_agent seekblessings

Retrieves all the blessings associated with a particular secret.

The output is base64-encoded-vom-encoded blessings that are compatible with the
"principal set" command.

Usage:
   cluster_agent seekblessings [flags] <secret>

<secret> is the secret to use.

The cluster_agent seekblessings flags are:
 -agent=
   The name or address of the cluster agent server.

Cluster_agent help

Help with no args displays the usage of the parent command.

Help with args displays the usage of the specified sub-command or help topic.

"help ..." recursively displays help for all commands and topics.

Usage:
   cluster_agent help [flags] [command/topic ...]

[command/topic ...] optionally identifies a specific sub-command or help topic.

The cluster_agent help flags are:
 -style=compact
   The formatting style for help output:
      compact   - Good for compact cmdline output.
      full      - Good for cmdline output, shows all global flags.
      godoc     - Good for godoc processing.
      shortonly - Only output short description.
   Override the default by setting the CMDLINE_STYLE environment variable.
 -width=<terminal width>
   Format output to this target width in runes, or unlimited if width < 0.
   Defaults to the terminal width if available.  Override the default by setting
   the CMDLINE_WIDTH environment variable.
*/
package main


text:
module SGF
  class DefaultEventListener
    include Debugger

    def initialize debug_mode = false
      enable_debug_mode if debug_mode
    end

    def start_game
      debug 'start_game'
    end

    def start_node
      debug 'start_node'
    end

    def property_name= name
      debug "property_name = '#{name}'"
    end

    def property_value= value
      debug "property_value = '#{value}'"
    end

    def start_variation
      debug "start_variation"
    end

    def end_variation
      debug "end_variation"
    end

    def end_game
      debug "end_game"
    end
  end
end


text:
<!DOCTYPE html>

	<meta name="generator" content="Hugo 0.62.2" />
  <meta charset="utf-8"/>
  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
  <meta name="viewport" content="width=device-width, initial-scale=1"/>

  <meta name="author"
        content="μFire"/>

  <meta name="description" content="Buy Arduino water sensor products online at the best price. Learn about our Sensor products."/>

    <meta name="keywords" content="uFire, water sensor arduino, industrial iot, industrial water sensors, agritech, microfire, raspberry pi water sensor, agtech">

  <link rel="canonical" href="http://ufire.co/"/>

  <link rel="alternate" type="application/rss+xml" href="http://ufire.co/index.xml">

  <title>μFire - Arduino Water Sensor - Buy Water Sensor Products Online</title>

  <link rel="shortcut icon" href="/images/favicon.ico"/>
  <link rel="stylesheet" href="/css/animate.min.css"/>
  <link rel="stylesheet" href="/css/remixicon.css"/>
  <link rel="stylesheet" href="/css/zozo.css"/>
  <link rel="stylesheet" href="/css/highlight.css"/>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@0.8.0/css/bulma.min.css">

        Home

        EC

        pH

        ORP

        Air

        PAR

        Shop

        Posts

          μFire

Measure pH, ORP, EC or salinity with an Arduino or Raspberry Pi

Welcome to μFire

<amp-carousel layout="container" type="carousel">
  <amp-img src="/images/ble-kit.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
  <amp-img src="/images/everything-2.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
  <amp-img src="/images/EC-front.jpg" height="300" width="300" alt="ISE Probe - Front"></amp-img>
  <amp-img src="/images/EC-back.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
  <amp-img src="/images/ISE-front.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
  <amp-img src="/images/ISE-back.jpg" height="300" width="300" alt="ISE Probe - Front"></amp-img>
  <amp-img src="/images/ISE_pH-probe.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
  <amp-img src="/images/ISE_pH-probe_temperature.jpg" height="300" width="300" alt="Conductivity Probe"></amp-img>
</amp-carousel>

Affordable, accurate, and easy-to-use water sensing devices

Measure pH, ORP, or EC, water temperature, air temperature and humidity, and PAR

Industry and developer friendly

An all-in-one solution; the connector, sensing circuitry, temperature sensor, and isolation hardware is all on one compact board

Recent Posts

Quickstart: EC Measurements

Get Started

 Read more about each measurement

ECpHORPAirPAR

 Are you a company interested in volume pricing, custom work, or a completed prototype?

Prototype BoxSend an Email

 Just want to buy our stuff?

Shop

About μFire

Ever want to make a hydroponic monitor? Something to track the nutrient solution and pH? You probably saw how much water sensors cost. If you are like us, you may have thought Why?. Why turned into I'll just make it myself. And that's where μFire. came from.

  Store Policies, Legal Stuff, Odds and Ends

<link  href="http://ufire.co/css/fancybox.min.css" rel="stylesheet">