#!/bin/sh
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# OPTIONS:
#   -f: start in foreground
#   -p <filename>: log the pid to a file (useful to kill it later)

# CONTROLLING STARTUP:
#
# This script relies on few environment variables to determine startup
# behavior, those variables are:
#
#   CLASSPATH -- A Java classpath containing everything necessary to run.
#   JVM_OPTS -- Additional arguments to the JVM for heap size, etc
#   CASSANDRA_CONF -- Directory containing Cassandra configuration files.
#
# As a convenience, a fragment of shell is sourced in order to set one or
# more of these variables. This so-called `include' can be placed in a
# number of locations and will be searched for in order. The lowest
# priority search path is the same directory as the startup script, and
# since this is the location of the sample in the project tree, it should
# almost work Out Of The Box.
#
# Any serious use-case though will likely require customization of the
# include. For production installations, it is recommended that you copy
# the sample to one of /usr/share/cassandra/cassandra.in.sh,
# /usr/local/share/cassandra/cassandra.in.sh, or
# /opt/cassandra/cassandra.in.sh and make your modifications there.
#
# Another option is to specify the full path to the include file in the
# environment. For example:
#
#   $ CASSANDRA_INCLUDE=/path/to/in.sh cassandra -p /var/run/cass.pid
#
# Note: This is particularly handy for running multiple instances on a
# single installation, or for quick tests.
#
# Finally, developers and enthusiasts who frequently run from an SVN
# checkout, and do not want to locally modify bin/cassandra.in.sh, can put
# a customized include file at ~/.cassandra.in.sh.
#
# If you would rather configure startup entirely from the environment, you
# can disable the include by exporting an empty CASSANDRA_INCLUDE, or by
# ensuring that no include files exist in the aforementioned search list.
# Be aware that you will be entirely responsible for populating the needed
# environment variables.

# If an include wasn't specified in the environment, then search for one...
if [ "x$CASSANDRA_INCLUDE" = "x" ]; then
    # Locations (in order) to use when searching for an include file.
    for include in /usr/share/cassandra/cassandra.in.sh \
                   /usr/local/share/cassandra/cassandra.in.sh \
                   /opt/cassandra/cassandra.in.sh \
                   ~/.cassandra.in.sh \
                   `dirname $0`/cassandra.in.sh; do
        if [ -r $include ]; then
            . $include
            break
        fi
    done
# ...otherwise, source the specified include.
elif [ -r $CASSANDRA_INCLUDE ]; then
    . $CASSANDRA_INCLUDE
fi

# Use JAVA_HOME if set, otherwise look for java in PATH
if [ -x $JAVA_HOME/bin/java ]; then
    JAVA=$JAVA_HOME/bin/java
else
    JAVA=`which java`
fi

if [ -z $CASSANDRA_CONF -o -z $CLASSPATH ]; then
    echo "You must set the CASSANDRA_CONF and CLASSPATH vars" >&2
    exit 1
fi

if [ -f "$CASSANDRA_CONF/cassandra-env.sh" ]; then
    . "$CASSANDRA_CONF/cassandra-env.sh"
fi

# Special-case path variables.
case "`uname`" in
    CYGWIN*)
        CLASSPATH=`cygpath -p -w "$CLASSPATH"`
        CASSANDRA_CONF=`cygpath -p -w "$CASSANDRA_CONF"`
    ;;
esac

launch_service()
{
    pidpath=$1
    foreground=$2
    props=$3
    class=$4
    cassandra_parms="-Dlog4j.configuration=log4j-server.properties -Dlog4j.defaultInitOverride=true"

    if [ "x$pidpath" != "x" ]; then
        cassandra_parms="$cassandra_parms -Dcassandra-pidfile=$pidpath"
    fi

    # The cassandra-foreground option will tell CassandraDaemon not
    # to close stdout/stderr, but it's up to us not to background.
    if [ "x$foreground" != "x" ]; then
        cassandra_parms="$cassandra_parms -Dcassandra-foreground=yes"
        exec $JAVA $JVM_OPTS $cassandra_parms -cp $CLASSPATH $props $class
    # Startup CassandraDaemon, background it, and write the pid.
    else
        exec $JAVA $JVM_OPTS $cassandra_parms -cp $CLASSPATH $props $class <&- &
        [ ! -z $pidpath ] && printf "%d" $! > $pidpath
    fi

    return $?
}

# Parse any command line options.
args=`getopt fhtp:bD: "$@"`
eval set -- "$args"

#classname="org.apache.cassandra.thrift.CassandraDaemon"
classname="com.datastax.brisk.BriskDaemon"

while true; do
    case "$1" in
        -p)
            pidfile="$2"
            shift 2
        ;;
        -f)
            foreground="yes"
            shift
        ;;
        -h)
            echo "Usage: $0 [-f] [-h] [-t] [-p pidfile]"
            exit 0
        ;;
        -t)
	    if [ -z $HADOOP_LOG_DIR ]; then
		echo "HADOOP_LOG_DIR not set; defaulting to $HADOOP_HOME/logs"
		export HADOOP_LOG_DIR=$HADOOP_HOME/logs
	    fi
            properties="$properties -Dhadoop-trackers=true -Dhadoop.log.dir=$HADOOP_LOG_DIR"
            hadoop_trackers="true"
            shift
        ;;
        -D)
            properties="$properties -D$2"
            shift 2
        ;;
        --)
            shift
            break
        ;;
        *)
            echo "Error parsing arguments!" >&2
            exit 1
        ;;
    esac
done

if [ -n "$hadoop_trackers" ]; then
    if [ -z $HADOOP_HOME ]; then
        echo "Please set HADOOP_HOME" >&2
        exit 1
    fi

    #needed for webapps
    CLASSPATH=$CLASSPATH:$HADOOP_HOME
    CLASSPATH=$CLASSPATH:$HADOOP_HOME/conf

    for jar in $HADOOP_HOME/*.jar $HADOOP_HOME/lib/*.jar $HADOOP_HOME/lib/jsp-2.1/*.jar; do
        CLASSPATH=$CLASSPATH:$jar
    done
fi

# Start up the service
launch_service "$pidfile" "$foreground" "$properties" "$classname"

exit $?

# vi:ai sw=4 ts=4 tw=0 et


class Clark < Formula
  desc "Fast, accurate and versatile kmer based classification system"
  homepage "http://clark.cs.ucr.edu/"
  # tag "bioinformatics"
  # doi "10.1186/s12864-015-1419-2"

  url "http://clark.cs.ucr.edu/Download/CLARKV1.2.3.tar.gz"
  sha256 "3223daa518a3f5c9f08af6f1a8cca669286672f87197c0c7f2e03504c44b37da"

  bottle do
    cellar :any
    sha256 "1ef50d25121c19b6567f3e5112897a08887189672bf408abeb24979fdbd061b5" => :el_capitan
    sha256 "361ed1106de564e044f96ce1ca82dd894c684ddf7ff58e417533cf567d71fa14" => :yosemite
    sha256 "52acdda74cbcec8a4815d998136784d8769c7c1e7efc7eeb2eab8a44552cbf98" => :mavericks
    sha256 "c7a4f65621a89f894109a50dda5c9614e64808fc30e6d449b8831f44a3be96bf" => :x86_64_linux
  end

  needs :openmp

  def install
    system "sh", "install.sh"
    bin.install Dir["exe/*"]
    doc.install "README.txt", "LICENSE_GNU_GPL.txt", "CHANGELOG"
    pkgshare.install Dir["*.sh"]
  end

  def caveats
    <<~EOS
    Additional helper scripts are installed in #{pkgshare}
    EOS
  end

  test do
    assert_match "k-spectrum", shell_output("#{bin}/CLARK 2>&1", 255)
  end
end


<?xml version="1.0"?>
<ZopeData>
  <record id="1" aka="AAAAAAAAAAE=">
    <pickle>
      <global name="ProxyField" module="Products.ERP5Form.ProxyField"/>
    </pickle>
    <pickle>
      <dictionary>
        <item>
            <key> <string>delegated_list</string> </key>
            <value>
              <list/>
            </value>
        </item>
        <item>
            <key> <string>id</string> </key>
            <value> <string>my_source_reference</string> </value>
        </item>
        <item>
            <key> <string>message_values</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>external_validator_failed</string> </key>
                    <value> <string>The input failed the external validator.</string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>overrides</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string></string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>tales</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string></string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>values</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string>my_view_mode_source_reference</string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string>Base_viewTradeFieldLibrary</string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string>Click to edit the target</string> </value>
                </item>
              </dictionary>
            </value>
        </item>
      </dictionary>
    </pickle>
  </record>
</ZopeData>


/**
 * Copyright 2011-2012 Adrian Stabiszewski, as@nfctools.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.nfctools.spi.scm;

import java.io.IOException;

import org.nfctools.api.Target;
import org.nfctools.nfcip.NFCIPConnection;
import org.nfctools.utils.NfcUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Scl3711Initiator implements NFCIPConnection {

	private Logger log = LoggerFactory.getLogger(getClass());

	private Scl3711 scl3711;
	private Target target;
	private byte[] buffer;

	public Scl3711Initiator(Scl3711 scl3711, Target target) {
		this.scl3711 = scl3711;
		this.target = target;
	}

	@Override
	public boolean isTarget() {
		return false;
	}

	@Override
	public boolean isInitiator() {
		return true;
	}

	@Override
	public byte[] receive() throws IOException {
		if (buffer.length != 2 && buffer[0] != 0 && log.isTraceEnabled())
			log.trace("receive => " + NfcUtils.convertBinToASCII(buffer));
		return buffer;
	}

	@Override
	public void send(byte[] data) throws IOException {
		if (data.length != 2 && data[0] != 0 && log.isTraceEnabled())
			log.trace("send    => " + NfcUtils.convertBinToASCII(data));
		buffer = scl3711.transceive(data);
	}

	@Override
	public void close() throws IOException {
		scl3711.disconnect();
	}

	//	@Override
	//	public void setTimeout(long millis) {
	//		throw new IllegalStateException();
	//	}

	@Override
	public byte[] getGeneralBytes() {
		return target.getGeneralBytes();
	}
}


/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.spark.network.server;

import org.apache.spark.network.protocol.Message;

/**
 * Handles either request or response messages coming off of Netty. A MessageHandler instance
 * is associated with a single Netty Channel (though it may have multiple clients on the same
 * Channel.)
 */
public abstract class MessageHandler<T extends Message> {
  /** Handles the receipt of a single message. */
  public abstract void handle(T message) throws Exception;

  /** Invoked when the channel this MessageHandler is on is active. */
  public abstract void channelActive();

  /** Invoked when an exception was caught on the Channel. */
  public abstract void exceptionCaught(Throwable cause);

  /** Invoked when the channel this MessageHandler is on is inactive. */
  public abstract void channelInactive();
}


<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2014 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_focused="true" android:drawable="@drawable/abc_btn_default_mtrl_shape"/>
    <item android:state_pressed="true" android:drawable="@drawable/abc_btn_default_mtrl_shape"/>
    <item android:drawable="@android:color/transparent"/>
</selector>


; RUN:  llvm-dis < %s.bc| FileCheck %s
; RUN:  verify-uselistorder < %s.bc

; Global constructors should no longer be upgraded when reading bitcode.
; CHECK: @llvm.global_ctors = appending global [0 x { i32, void ()* }] zeroinitializer


require 'rails/generators/test_unit'

module TestUnit
  module Generators
    class OauthProviderGenerator < Base
      source_root File.expand_path('../templates', __FILE__)

      argument :name, :type => :string, :default => 'Oauth'
      class_option :fixture, :type => :boolean

      def copy_controller_test_files
        template 'clients_controller_test.rb',
                 File.join('test/functional', class_path, "#{file_name}_clients_controller_test.rb")
      end

      def copy_models_test_files
        template 'client_application_test.rb',  File.join('test/unit', 'client_application_test.rb')
        template 'oauth_token_test.rb',         File.join('test/unit', 'oauth_token_test.rb')
        template 'oauth_nonce_test.rb',         File.join('test/unit', 'oauth_nonce_test.rb')
      end

      hook_for :fixture_replacement

      def create_fixture_file
        if options[:fixtures] && options[:fixture_replacement].nil?
          template 'client_applications.yml',   File.join('test/fixtures', 'client_applications.yml')
          template 'oauth_tokens.yml',          File.join('test/fixtures', 'oauth_tokens.yml')
          template 'oauth_nonces.yml',          File.join('test/fixtures', 'oauth_nonces.yml')
        end
      end
    end
  end
end


import Comp from './index.vue'

import { mount } from 'vue-test-utils'
import { expect } from 'chai'

describe('Loading', () => {
  it('basic', () => {
    const wrapper = mount(Comp)
    expect(wrapper.name()).to.equal('loading')
  })
})


<?php
namespace GuzzleHttp\Tests\Psr7;

require __DIR__ . '/../vendor/autoload.php';

class HasToString
{
    public function __toString() {
        return 'foo';
    }
}


// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef V8_PREPARSE_DATA_H_
#define V8_PREPARSE_DATA_H_

#include "allocation.h"
#include "hashmap.h"
#include "utils-inl.h"

namespace v8 {
namespace internal {

// ----------------------------------------------------------------------------
// ParserRecorder - Logging of preparser data.

// Abstract interface for preparse data recorder.
class ParserRecorder {
 public:
  ParserRecorder() { }
  virtual ~ParserRecorder() { }

  // Logs the scope and some details of a function literal in the source.
  virtual void LogFunction(int start,
                           int end,
                           int literals,
                           int properties,
                           LanguageMode language_mode) = 0;

  // Logs a symbol creation of a literal or identifier.
  virtual void LogAsciiSymbol(int start, Vector<const char> literal) { }
  virtual void LogUtf16Symbol(int start, Vector<const uc16> literal) { }

  // Logs an error message and marks the log as containing an error.
  // Further logging will be ignored, and ExtractData will return a vector
  // representing the error only.
  virtual void LogMessage(int start,
                          int end,
                          const char* message,
                          const char* argument_opt) = 0;

  virtual int function_position() = 0;

  virtual int symbol_position() = 0;

  virtual int symbol_ids() = 0;

  virtual Vector<unsigned> ExtractData() = 0;

  virtual void PauseRecording() = 0;

  virtual void ResumeRecording() = 0;
};

// ----------------------------------------------------------------------------
// FunctionLoggingParserRecorder - Record only function entries

class FunctionLoggingParserRecorder : public ParserRecorder {
 public:
  FunctionLoggingParserRecorder();
  virtual ~FunctionLoggingParserRecorder() {}

  virtual void LogFunction(int start,
                           int end,
                           int literals,
                           int properties,
                           LanguageMode language_mode) {
    function_store_.Add(start);
    function_store_.Add(end);
    function_store_.Add(literals);
    function_store_.Add(properties);
    function_store_.Add(language_mode);
  }

  // Logs an error message and marks the log as containing an error.
  // Further logging will be ignored, and ExtractData will return a vector
  // representing the error only.
  virtual void LogMessage(int start,
                          int end,
                          const char* message,
                          const char* argument_opt);

  virtual int function_position() { return function_store_.size(); }

  virtual Vector<unsigned> ExtractData() = 0;

  virtual void PauseRecording() {
    pause_count_++;
    is_recording_ = false;
  }

  virtual void ResumeRecording() {
    ASSERT(pause_count_ > 0);
    if (--pause_count_ == 0) is_recording_ = !has_error();
  }

 protected:
  bool has_error() {
    return static_cast<bool>(preamble_[PreparseDataConstants::kHasErrorOffset]);
  }

  bool is_recording() {
    return is_recording_;
  }

  void WriteString(Vector<const char> str);

  Collector<unsigned> function_store_;
  unsigned preamble_[PreparseDataConstants::kHeaderSize];
  bool is_recording_;
  int pause_count_;

#ifdef DEBUG
  int prev_start_;
#endif
};

// ----------------------------------------------------------------------------
// PartialParserRecorder - Record only function entries

class PartialParserRecorder : public FunctionLoggingParserRecorder {
 public:
  PartialParserRecorder() : FunctionLoggingParserRecorder() { }
  virtual void LogAsciiSymbol(int start, Vector<const char> literal) { }
  virtual void LogUtf16Symbol(int start, Vector<const uc16> literal) { }
  virtual ~PartialParserRecorder() { }
  virtual Vector<unsigned> ExtractData();
  virtual int symbol_position() { return 0; }
  virtual int symbol_ids() { return 0; }
};

// ----------------------------------------------------------------------------
// CompleteParserRecorder -  Record both function entries and symbols.

class CompleteParserRecorder: public FunctionLoggingParserRecorder {
 public:
  CompleteParserRecorder();
  virtual ~CompleteParserRecorder() { }

  virtual void LogAsciiSymbol(int start, Vector<const char> literal) {
    if (!is_recording_) return;
    int hash = vector_hash(literal);
    LogSymbol(start, hash, true, Vector<const byte>::cast(literal));
  }

  virtual void LogUtf16Symbol(int start, Vector<const uc16> literal) {
    if (!is_recording_) return;
    int hash = vector_hash(literal);
    LogSymbol(start, hash, false, Vector<const byte>::cast(literal));
  }

  virtual Vector<unsigned> ExtractData();

  virtual int symbol_position() { return symbol_store_.size(); }
  virtual int symbol_ids() { return symbol_id_; }

 private:
  struct Key {
    bool is_ascii;
    Vector<const byte> literal_bytes;
  };

  virtual void LogSymbol(int start,
                         int hash,
                         bool is_ascii,
                         Vector<const byte> literal);

  template <typename Char>
  static int vector_hash(Vector<const Char> string) {
    int hash = 0;
    for (int i = 0; i < string.length(); i++) {
      int c = static_cast<int>(string[i]);
      hash += c;
      hash += (hash << 10);
      hash ^= (hash >> 6);
    }
    return hash;
  }

  static bool vector_compare(void* a, void* b) {
    Key* string1 = reinterpret_cast<Key*>(a);
    Key* string2 = reinterpret_cast<Key*>(b);
    if (string1->is_ascii != string2->is_ascii) return false;
    int length = string1->literal_bytes.length();
    if (string2->literal_bytes.length() != length) return false;
    return memcmp(string1->literal_bytes.start(),
                  string2->literal_bytes.start(), length) == 0;
  }

  // Write a non-negative number to the symbol store.
  void WriteNumber(int number);

  Collector<byte> literal_chars_;
  Collector<byte> symbol_store_;
  Collector<Key> symbol_keys_;
  HashMap symbol_table_;
  int symbol_id_;
};

} }  // namespace v8::internal.

#endif  // V8_PREPARSE_DATA_H_


    <RelativeLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/settings_item"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:paddingBottom="8dip"
        android:paddingLeft="8dip"
        android:paddingRight="8dip"
        android:paddingTop="6dip"
        android:background="@android:drawable/list_selector_background"
        >
        <TextView
            android:id="@+id/setting_name"
            style="@android:style/TextAppearance.Holo.SearchResult.Title"
            android:text="@string/setting_remote_content"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginRight="14dip"
            android:textSize="20sp"/>

        <RadioGroup
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@id/setting_name"
            android:layout_marginTop="10dip"
            android:layout_marginLeft="2dip"
            android:layout_marginRight="10dip"
            >
            <RadioButton
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:id="@+id/setting_remote_content_always"
                android:text="@string/setting_remote_content_always"
                android:layout_marginBottom="5dip"
                />
            <RadioButton
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:id="@+id/setting_remote_content_wifi"
                android:text="@string/setting_remote_content_wifi"
                android:layout_marginBottom="5dip"
                />
            <RadioButton
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:id="@+id/setting_remote_content_never"
                android:text="@string/setting_remote_content_never"
                android:layout_marginBottom="5dip"
                />

        </RadioGroup>

    </RelativeLayout>


        texture{ pigment{ color rgb <0.95,0.750,0.05> }
                 normal { wood 2.5 scale 0.15 }
                 finish { phong 1  reflection{ 0.25 } }
               }  // end of texture ---------------------------


#
# Makefile for MPT based block devices
#

obj-$(CONFIG_I2O)	+= i2o/
obj-$(CONFIG_FUSION)	+= fusion/


# go-pry

go-pry - an interactive REPL for Go that allows you to drop into your code at any point.

[![Build Status](https://travis-ci.org/d4l3k/go-pry.svg?branch=master)](https://travis-ci.org/d4l3k/go-pry)
[![GoDoc](https://godoc.org/github.com/d4l3k/go-pry/pry?status.svg)](https://godoc.org/github.com/d4l3k/go-pry/pry)

![go-pry](https://i.imgur.com/yr1BEsK.png)

Example

![go-pry Animated Example](https://i.imgur.com/H8hFzPV.gif)
![go-pry Example](https://i.imgur.com/0rmwVY7.png)

## Usage

Install go-pry
```bash
go get github.com/d4l3k/go-pry
go install -i github.com/d4l3k/go-pry

```

Add the pry statement to the code
```go
package main

import "github.com/d4l3k/go-pry/pry"

func main() {
  a := 1
  pry.Pry()
}
```

Run the code as you would normally with the `go` command. go-pry is just a wrapper.
```bash
# Run
go-pry run readme.go
```

If you want completions to work properly, also install `gocode` if it
is not installed in your system

```bash
go get -u github.com/nsf/gocode
```

## How does it work?
go-pry is built using a combination of meta programming as well as a massive amount of reflection. When you invoke the go-pry command it looks at the Go files in the mentioned directories (or the current in cases such as `go-pry build`) and processes them. Since Go is a compiled language there's no way to dynamically get in scope variables, and even if there was, unused imports would be automatically removed for optimization purposes. Thus, go-pry has to find every instance of `pry.Pry()` and inject a large blob of code that contains references to all in scope variables and functions as well as those of the imported packages. When doing this it makes a copy of your file to `.<filename>.gopry` and modifies the `<filename>.go` then passes the command arguments to the standard `go` command. Once the command exits, it restores the files.

If the program unexpectedly fails there is a custom command `go-pry restore [files]` that will move the files back. An alternative is to just remove the `pry.Apply(...)` line.

## Inspiration

go-pry is greatly inspired by [Pry REPL](http://pryrepl.org) for Ruby.

## License

go-pry is licensed under the MIT license.

Made by [Tristan Rice](https://fn.lc).


/*
 * Copyright (C) 2014 nohana, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.valuesfeng.picker;

import android.app.Activity;
import android.content.Intent;
import android.net.Uri;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;

import com.bumptech.glide.Glide;
import com.squareup.picasso.Picasso;

import java.io.Serializable;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import io.valuesfeng.picker.engine.LoadEngine;
import io.valuesfeng.picker.model.SelectionSpec;

/**
 *
 * thanks for:
 *
 * https://github.com/nohana/Laevatein
 */
public final class Picker {
    private static final String INITIALIZE_PICKER_ERROR = "Try to initialize Picker which had already been initialized before";
    private static boolean hasInitPicker;
    private final WeakReference<Activity> mContext;
    private final WeakReference<Fragment> mFragment;
    private final Set<MimeType> mMimeType;
    private final SelectionSpec mSelectionSpec;
    private LoadEngine engine;      //图片加载器 glide  imageloder picasso
    private List<Uri> mResumeList;

    Picker(Activity activity, Fragment fragment, Set<MimeType> mimeType) {
        mContext = new WeakReference<>(activity);
        if (fragment != null)
            mFragment = new WeakReference<>(fragment);
        else
            mFragment = null;
        mMimeType = mimeType;
        mSelectionSpec = new SelectionSpec();
        mResumeList = new ArrayList<>();
    }

    Picker(Activity activity, Fragment fragment) {
        mContext = new WeakReference<>(activity);
        if (fragment != null)
            mFragment = new WeakReference<>(fragment);
        else
            mFragment = null;
        mMimeType = MimeType.allOf();
        mSelectionSpec = new SelectionSpec();
        mResumeList = new ArrayList<>();
    }

    /**
     * set iamge  load engine
     *
     * @param engine
     * @return
     */
    public Picker setEngine(LoadEngine engine) {
        this.engine = engine;
        return this;
    }

    /**
     * set the first item open camera
     *
     * @param mEnableCamera
     * @return
     */
    public Picker enableCamera(boolean mEnableCamera) {
        mSelectionSpec.setmEnableCamera(mEnableCamera);
        return this;
    }

    /**
     * set if should start the camera by default
     *
     * @param mStartWithCamera
     * @return
     */
    public Picker startCamera(boolean mStartWithCamera) {
        mSelectionSpec.startWithCamera(mStartWithCamera);
        return this;
    }

    /**
     * Sets the limitation of a selectable count within the specified range.
     *
     * @param min minimum value to select.
     * @param max maximum value to select.
     * @return the specification builder context.
     */
    public Picker count(int min, int max) {
        mSelectionSpec.setMinSelectable(min);
        mSelectionSpec.setMaxSelectable(max);
        return this;
    }

    /**
     * Sets the limitation of a selectable count within the specified range.
     *
     * @param max maximum value to select.
     * @return the specification builder context.
     */
    public Picker count(int max) {
        mSelectionSpec.setMinSelectable(0);
        mSelectionSpec.setMaxSelectable(max);
        return this;
    }

    public Picker singleChoice() {
        count(0, 1);
        return this;
    }

    //TODO : Wait achieve
    /**
     * Sets the limitation of a selectable image quality by pixel count within the specified range.
     *
     * @param minPixel minimum value to select.
     * @param maxPixel maximum value to select.
     * @return the specification builder context.
     */
    public Picker quality(int minPixel, int maxPixel) {
        mSelectionSpec.setMinPixels(minPixel);
        mSelectionSpec.setMaxPixels(maxPixel);
        return this;
    }

    /**
     * Sets the default selection to resume photo picking activity.
     *
     * @param uriList to set selected as default.
     * @return the specification builder context.
     */
    public Picker resume(List<Uri> uriList) {
        if (uriList == null) { // nothing to do.
            return this;
        }
        mResumeList.addAll(uriList);
        return this;
    }

    /**
     * Start to select photo.
     *
     * @param requestCode identity of the requester activity.
     */
    public void forResult(int requestCode) {
        if (engine == null)
            throw new ExceptionInInitializerError(LoadEngine.INITIALIZE_ENGINE_ERROR);

        Activity activity = getActivity();
        if (activity == null) {
            return; // cannot continue;
        }
        mSelectionSpec.setMimeTypeSet(mMimeType);
        mSelectionSpec.setEngine(engine);
        Intent intent = new Intent(activity, ImageSelectActivity.class);
        intent.putExtra(ImageSelectActivity.EXTRA_SELECTION_SPEC, mSelectionSpec);
//        intent.putExtra(ImageSelectActivity.EXTRA_ENGINE, (Serializable) engine);
        intent.putParcelableArrayListExtra(ImageSelectActivity.EXTRA_RESUME_LIST, (ArrayList<? extends android.os.Parcelable>) mResumeList);

        Fragment fragment = getFragment();
        if (fragment != null) {
            fragment.startActivityForResult(intent, requestCode);
        } else {
            activity.startActivityForResult(intent, requestCode);
        }
        hasInitPicker = false;
    }

    public static Picker from(Activity activity) {
        if (hasInitPicker)
            throw new ExceptionInInitializerError(INITIALIZE_PICKER_ERROR);
        hasInitPicker = true;
        return new Picker(activity, null);
    }

    public static Picker from(Activity activity, Set<MimeType> mimeType) {
        if (hasInitPicker)
            throw new ExceptionInInitializerError(INITIALIZE_PICKER_ERROR);
        hasInitPicker = true;
        return new Picker(activity, null, mimeType);
    }

    public static Picker from(Fragment fragment) {
        if (hasInitPicker)
            throw new ExceptionInInitializerError(INITIALIZE_PICKER_ERROR);
        hasInitPicker = true;
        return new Picker(fragment.getActivity(), fragment);
    }

    public static Picker from(Fragment fragment, Set<MimeType> mimeType) {
        if (hasInitPicker)
            throw new ExceptionInInitializerError(INITIALIZE_PICKER_ERROR);
        hasInitPicker = true;
        return new Picker(fragment.getActivity(), fragment, mimeType);
    }

    /**
     * @return the actual requester context.
     */
    @Nullable
    Activity getActivity() {
        return mContext.get();
    }

    /**
     * @return the fragment that is responsible for result handling.
     */
    @Nullable
    Fragment getFragment() {
        return mFragment != null ? mFragment.get() : null;
    }

}


/*
 * Copyright 2012 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors: Ben Skeggs
 */

#include "nouveau_drv.h"
#include "nouveau_dma.h"
#include "nouveau_fence.h"

#include "nv50_display.h"

static int
nvc0_fence_emit32(struct nouveau_channel *chan, u64 virtual, u32 sequence)
{
	int ret = RING_SPACE(chan, 6);
	if (ret == 0) {
		BEGIN_NVC0(chan, 0, NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH, 5);
		OUT_RING  (chan, upper_32_bits(virtual));
		OUT_RING  (chan, lower_32_bits(virtual));
		OUT_RING  (chan, sequence);
		OUT_RING  (chan, NV84_SUBCHAN_SEMAPHORE_TRIGGER_WRITE_LONG);
		OUT_RING  (chan, 0x00000000);
		FIRE_RING (chan);
	}
	return ret;
}

static int
nvc0_fence_sync32(struct nouveau_channel *chan, u64 virtual, u32 sequence)
{
	int ret = RING_SPACE(chan, 5);
	if (ret == 0) {
		BEGIN_NVC0(chan, 0, NV84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH, 4);
		OUT_RING  (chan, upper_32_bits(virtual));
		OUT_RING  (chan, lower_32_bits(virtual));
		OUT_RING  (chan, sequence);
		OUT_RING  (chan, NV84_SUBCHAN_SEMAPHORE_TRIGGER_ACQUIRE_GEQUAL |
				 NVC0_SUBCHAN_SEMAPHORE_TRIGGER_YIELD);
		FIRE_RING (chan);
	}
	return ret;
}

static int
nvc0_fence_context_new(struct nouveau_channel *chan)
{
	int ret = nv84_fence_context_new(chan);
	if (ret == 0) {
		struct nv84_fence_chan *fctx = chan->fence;
		fctx->base.emit32 = nvc0_fence_emit32;
		fctx->base.sync32 = nvc0_fence_sync32;
	}
	return ret;
}

int
nvc0_fence_create(struct nouveau_drm *drm)
{
	int ret = nv84_fence_create(drm);
	if (ret == 0) {
		struct nv84_fence_priv *priv = drm->fence;
		priv->base.context_new = nvc0_fence_context_new;
	}
	return ret;
}


tests.register("lang-toArray",
	[

		/* no partial in embed API

		function partial(t){
			var scope = { foo: "bar" };
			var scope2 = { foo: "baz" };
			function thinger(arg1, arg2){
				return [this.foo, arg1, arg2];
			}

			var st1 = dojo.partial(thinger);
			t.assertEqual("bar", st1.call(scope)[0]);
			t.assertEqual(undefined, st1()[0]);
			var st2 = dojo.partial(thinger, "foo", "bar");
			t.assertEqual("bar", st2()[2]);
			var st3 = dojo.partial(thinger, "foo", "bar");
		},

		function nestedPartial(t){
			function thinger(arg1, arg2){
				return [arg1, arg2];
			}

			var st1 = dojo.partial(thinger, "foo");
			t.assertEqual(undefined, st1()[1]);
			t.assertEqual("bar", st1("bar")[1]);

			// partials can accumulate
			var st2 = dojo.partial(st1, "thud");
			t.assertEqual("foo", st2()[0]);
			t.assertEqual("thud", st2()[1]);
		},

		*/

		function toArray(t){
			var obj1 = [ 'foo', 'bar', 'spam', 'ham' ];

			function thinger(){
				return dojo.toArray(arguments);
			}
			var obj2 = thinger.apply(this, obj1);
			t.assertEqual(obj1[0], obj2[0]);
		},

		function toArrayDOM(t){
			//test DomCollection
			var div = document.createElement('div');
			div.innerHTML="linktext";
			var r=dojo.toArray(div.childNodes);
			t.is(2,r.length);
		}

	]
);


<depthIntrinsics>
    <ppx>320.000000000</ppx>
    <ppy>240.000000000</ppy>
    <fovx>575.815734863</fovx>
    <fovy>575.815734863</fovy>
    <width>640.000000000</width>
    <height>480.000000000</height>
</depthIntrinsics>
<colorIntrinsics>
    <ppx>960.122253418</ppx>
    <ppy>519.567443848</ppy>
    <fovx>1318.971313477</fovx>
    <fovy>1321.069580078</fovy>
    <width>1920.000000000</width>
    <height>1080.000000000</height>
    <dK>
        <k0>-0.126587495</k0>
        <k1>0.151592717</k1>
        <k2>-0.077532344</k2>
    </dK>
    <dP>
        <p0>-0.001272243</p0>
        <p1>0.000248429</p1>
    </dP>
</colorIntrinsics>
<extrinsics>
    <rotation>
        <r0>0.999816179</r0>
        <r1>0.001299028</r1>
        <r2>-0.019129671</r2>
        <r3>-0.002510520</r3>
        <r4>0.997982264</r4>
        <r5>-0.063443430</r5>
        <r6>0.019008659</r6>
        <r7>0.063479796</r7>
        <r8>0.997802079</r8>
    </rotation>
    <translation>
        <t0>-3.953440666</t0>
        <t1>-1.376315713</t1>
        <t2>-33.605842590</t2>
    </translation>
</extrinsics>
<adjustment>
    <translate>
        <x>0.000000000</x>
        <y>0.000000000</y>
        <z>0.000000000</z>
    </translate>
    <rotate>
        <x>1.458332062</x>
        <y>-1.458333969</y>
        <z>0.000000000</z>
    </rotate>
    <scale>
        <x>1.002083302</x>
        <y>1.000000000</y>
    </scale>
    <depth>
        <min>478.000000000</min>
        <max>1012.000000000</max>
    </depth>
</adjustment>
<skin>
    <targetR>0.886274576</targetR>
    <targetG>0.760784388</targetG>
    <targetB>0.674509823</targetB>
    <hueWeight>0.437500000</hueWeight>
    <satWeight>0.375000000</satWeight>
    <brightWeight>0.260416657</brightWeight>
    <lowerThreshold>0.187500000</lowerThreshold>
    <upperThreshold>0.531250000</upperThreshold>
</skin>
<face>
    <x>-63.584575653</x>
    <y>-171.813644409</y>
    <z>779.000000000</z>
</face>


//
//     Generated by class-dump 3.5 (64 bit).
//
//     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by Steve Nygard.
//

#import <SAObjects/SABaseClientBoundCommand.h>

@interface SACancelSucceeded : SABaseClientBoundCommand
{
}

+ (id)cancelSucceededWithDictionary:(id)arg1 context:(id)arg2;
+ (id)cancelSucceeded;
- (BOOL)requiresResponse;
- (id)encodedClassName;
- (id)groupIdentifier;

@end


import React from "react";
import Helmet from "@treats/helmet";
import { FormattedMessage, injectIntl<%if(USE_TYPESCRIPT)%>, InjectedIntlProps<%endif%> } from "@treats/intl";
import AsyncComponent from "@treats/component/async-component";

import style from "./welcome.css";
import treats from "./treats.png";

/**
 *  Welcome to treats component
 *  @param props React props
 *  @param props.intl Intl Object
 *  @author Tokopedia Engineering
 */
const Welcome = ({ intl }<%if(USE_TYPESCRIPT)%>: InjectedIntlProps<%endif%>) => (

        <Helmet>
            <title>Welcome to Treats!</title>
        </Helmet>

Welcome, let's have some treats!

            <FormattedMessage
                id="welcome_page__description1"
                values={{
                    React: (

                            React

                    ),
                    Redux: (

                            Redux

                    ),
                    GraphQL: (

                            GraphQL

                    )
                }}
            />

                <FormattedMessage
                    id="welcome_page__description2"
                    values={{
                        Source: src/page/welcome.js,
                        Documentation: (

                                documentation

                        )
                    }}
                />

                    English

                    Indonesian

);

export default AsyncComponent(module, injectIntl(Welcome));