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

    Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
    under one or more contributor license agreements. See the NOTICE file
    distributed with this work for additional information regarding copyright
    ownership. Camunda licenses this file to you under the Apache License,
    Version 2.0; 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.

-->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="org.camunda.bpm.engine.history.HistoricActivityStatistics">

  <!-- RESULTMAP -->

  <resultMap id="historicActivityStatisticsResultMap" type="org.camunda.bpm.engine.impl.persistence.entity.HistoricActivityStatisticsImpl">
    <id property="id" column="ID_" jdbcType="VARCHAR" />
    <result property="instances" column="INSTANCE_COUNT_" jdbcType="INTEGER" />
    <result property="finished" column="FINISHED_COUNT_" jdbcType="INTEGER" />
    <result property="canceled" column="CANCELED_COUNT_" jdbcType="INTEGER" />
    <result property="completeScope" column="COMPLETE_SCOPE_COUNT_" jdbcType="INTEGER" />
    <result property="openIncidents" column="OPEN_INCIDENT_COUNT_" jdbcType="INTEGER" />
    <result property="resolvedIncidents" column="RESOLVED_INCIDENT_COUNT_" jdbcType="INTEGER" />
    <result property="deletedIncidents" column="DELETED_INCIDENT_COUNT_" jdbcType="INTEGER" />
  </resultMap>

  <resultMap id="historicCaseActivityStatisticsResultMap" type="org.camunda.bpm.engine.impl.persistence.entity.HistoricCaseActivityStatisticsImpl">
    <id property="id" column="ID_" jdbcType="VARCHAR" />
    <result property="available" column="AVAILABLE_" jdbcType="INTEGER" />
    <result property="enabled" column="ENABLED_" jdbcType="INTEGER" />
    <result property="disabled" column="DISABLED_" jdbcType="INTEGER" />
    <result property="active" column="ACTIVE_" jdbcType="INTEGER" />
    <result property="terminated" column="TERMINATED_" jdbcType="INTEGER" />
    <result property="completed" column="COMPLETED_" jdbcType="INTEGER" />
  </resultMap>

  <!-- HistoricActivity statistics -->

  <select id ="selectHistoricActivityStatistics" resultMap="historicActivityStatisticsResultMap"
    parameterType="org.camunda.bpm.engine.impl.HistoricActivityStatisticsQueryImpl">
    <include refid="org.camunda.bpm.engine.impl.persistence.entity.Commons.bindOrderBy"/>
    ${limitBefore}
    select RES.*
    ${limitBetween}
    <include refid="selectHistoricActivityStatisticsByQueryCriteriaSql"/>
    ${orderBy}
    ${limitAfter}
  </select>

  <select id ="selectHistoricActivityStatisticsCount" resultType="long"
    parameterType="org.camunda.bpm.engine.impl.HistoricActivityStatisticsQueryImpl">
    ${countDistinctBeforeStart} RES.ID_ ${countDistinctBeforeEnd}
    <include refid="selectHistoricActivityStatisticsByQueryCriteriaSql"/>
    ${countDistinctAfterEnd}
  </select>

  <sql id="selectHistoricActivityStatisticsByQueryCriteriaSql">
    from (

      <!-- in case of fetching the incidents number ("includeIncidents")
           a UNION and second aggregation are required for the final result -->
      <if test="includeIncidents">
      select ID_,
        sum(INSTANCE_COUNT_) as INSTANCE_COUNT_
        <if test="includeFinished">
        , sum(FINISHED_COUNT_) as FINISHED_COUNT_
        </if>
        <if test="includeCanceled">
        , sum(CANCELED_COUNT_) as CANCELED_COUNT_
        </if>
        <if test="includeCompleteScope">
        , sum(COMPLETE_SCOPE_COUNT_) as COMPLETE_SCOPE_COUNT_
        </if>
        <if test="includeIncidents">
        , sum(OPEN_INCIDENT_COUNT_) as OPEN_INCIDENT_COUNT_
        , sum(RESOLVED_INCIDENT_COUNT_) as RESOLVED_INCIDENT_COUNT_
        , sum(DELETED_INCIDENT_COUNT_) as DELETED_INCIDENT_COUNT_
        </if>
      from (
      </if>

          select ACT.ACT_ID_ as ID_,
            sum(CASE WHEN ACT.END_TIME_ is NULL THEN 1 ELSE 0 END) as INSTANCE_COUNT_
            <if test="includeFinished">
            , sum(CASE WHEN ACT.END_TIME_ is not NULL THEN 1 ELSE 0 END) as FINISHED_COUNT_
            </if>
            <if test="includeCanceled">
            , sum(CASE WHEN ACT.ACT_INST_STATE_ = 2 THEN 1 ELSE 0 END) as CANCELED_COUNT_
            </if>
            <if test="includeCompleteScope">
            , sum(CASE WHEN ACT.ACT_INST_STATE_ = 1 THEN 1 ELSE 0 END) as COMPLETE_SCOPE_COUNT_
            </if>
            <if test="includeIncidents">
            , 0${numericCast} as OPEN_INCIDENT_COUNT_
            , 0${numericCast} as RESOLVED_INCIDENT_COUNT_
            , 0${numericCast} as DELETED_INCIDENT_COUNT_
            </if>

          from ${prefix}ACT_HI_ACTINST ACT

          <if test="startedBefore != null || startedAfter != null || finishedBefore != null || finishedAfter != null">
            INNER JOIN ${prefix}ACT_HI_PROCINST PI
            ON ACT.PROC_INST_ID_ = PI.ID_
          </if>

          where ACT.PROC_DEF_ID_ = #{processDefinitionId}
            <if test="!includeFinished">
              and (
                ACT.END_TIME_ is null
              <if test="includeCanceled">
                or ACT.ACT_INST_STATE_ = 2
              </if>
              <if test="includeCompleteScope">
                or ACT.ACT_INST_STATE_ = 1
              </if>
              )
            </if>

          <include refid="applyStatisticsFilters" />

          <if test="processInstanceIds != null">
            and ACT.PROC_INST_ID_ in
            <foreach item="processInstanceId" index="index" collection="processInstanceIds"
                open="(" separator="," close=")">
              #{processInstanceId}
            </foreach>
          </if>

          GROUP BY ACT_ID_

      <if test="includeIncidents">
        UNION
            select
              INC.ACTIVITY_ID_ as ID_,
              0${numericCast} as INSTANCE_COUNT_
              <if test="includeFinished">
              , 0${numericCast} as FINISHED_COUNT_
              </if>
              <if test="includeCanceled">
              , 0${numericCast} as CANCELED_COUNT_
              </if>
              <if test="includeCompleteScope">
              , 0${numericCast} as COMPLETE_SCOPE_COUNT_
              </if>
              , sum(CASE WHEN INC.INCIDENT_STATE_ = 0 THEN 1 ELSE 0 END) as OPEN_INCIDENT_COUNT_
              , sum(CASE WHEN INC.INCIDENT_STATE_ = 1 THEN 1 ELSE 0 END) as RESOLVED_INCIDENT_COUNT_
              , sum(CASE WHEN INC.INCIDENT_STATE_ = 2 THEN 1 ELSE 0 END) as DELETED_INCIDENT_COUNT_
            from ${prefix}ACT_HI_INCIDENT INC

            <if test="startedBefore != null || startedAfter != null || finishedBefore != null || finishedAfter != null">
              INNER JOIN ${prefix}ACT_HI_PROCINST PI
              ON INC.PROC_INST_ID_ = PI.ID_
            </if>

            where INC.PROC_DEF_ID_ = #{processDefinitionId}

            <include refid="applyStatisticsFilters" />

            <if test="processInstanceIds != null">
              and INC.PROC_INST_ID_ in
              <foreach item="processInstanceId" index="index" collection="processInstanceIds"
                  open="(" separator="," close=")">
                #{processInstanceId}
              </foreach>
            </if>

            GROUP BY INC.ACTIVITY_ID_
      ) RES
      GROUP BY ID_
      </if>

    ) RES
  </sql>

  <sql id="applyStatisticsFilters">
    <if test="startedBefore != null">
      and PI.START_TIME_ <= #{startedBefore}
    </if>
    <if test="startedAfter != null">
      and PI.START_TIME_ >= #{startedAfter}
    </if>
    <if test="finishedBefore != null">
      and PI.END_TIME_ <= #{finishedBefore}
    </if>
    <if test="finishedAfter != null">
      and PI.END_TIME_ >= #{finishedAfter}
    </if>
  </sql>

  <!-- HistoricCaseActivity statistics -->

  <select id ="selectHistoricCaseActivityStatistics" resultMap="historicCaseActivityStatisticsResultMap"
    parameterType="org.camunda.bpm.engine.impl.HistoricCaseActivityStatisticsQueryImpl">
    <include refid="org.camunda.bpm.engine.impl.persistence.entity.Commons.bindOrderBy"/>
    ${limitBefore}
    select RES.*
    ${limitBetween}
    <include refid="selectHistoricCaseActivityStatisticsByQueryCriteriaSql"/>
    ${orderBy}
    ${limitAfter}
  </select>

  <select id ="selectHistoricCaseActivityStatisticsCount" resultType="long"
    parameterType="org.camunda.bpm.engine.impl.HistoricCaseActivityStatisticsQueryImpl">
    ${countDistinctBeforeStart} RES.ID_ ${countDistinctBeforeEnd}
    <include refid="selectHistoricCaseActivityStatisticsByQueryCriteriaSql"/>
    ${countDistinctAfterEnd}
  </select>

  <sql id="selectHistoricCaseActivityStatisticsByQueryCriteriaSql">
    from (
      select
        HCAI.CASE_ACT_ID_ as ID_
      , count( CASE WHEN HCAI.STATE_ = 1 THEN 1 ELSE null END ) as AVAILABLE_
      , count( CASE WHEN HCAI.STATE_ = 2 THEN 1 ELSE null END ) as ENABLED_
      , count( CASE WHEN HCAI.STATE_ = 3 THEN 1 ELSE null END ) as DISABLED_
      , count( CASE WHEN HCAI.STATE_ = 4 THEN 1 ELSE null END ) as ACTIVE_
      , count( CASE WHEN HCAI.STATE_ = 6 THEN 1 ELSE null END ) as TERMINATED_
      , count( CASE WHEN HCAI.STATE_ = 7 THEN 1 ELSE null END ) as COMPLETED_
      from
        ${prefix}ACT_HI_CASEACTINST HCAI
      where
        HCAI.CASE_DEF_ID_ = #{caseDefinitionId}
      group by HCAI.CASE_ACT_ID_
    ) RES
  </sql>

</mapper>


text:
RouteNeo is a successor to [RouteOne](https://github.com/hroll/poke-router)
that is planned to support additional features like simulating battles and
reporting the probabilities of different outcomes.

Currently, RouteNeo is under active construction.
RouteNeo is able to generate the same damage calculations as RouteOne,
but does not currently do inventory and money management.

## Features Present

* Stat computation
* Track experience and stat experience
* Track moveset for party Pokemon
* Automatically derive moveset for enemy pokemon
* Print damage calculations

## Features Planned

* Simulate Trainer AI and battle state (partially implemented)
* Inventory management

redpajama_set_name: RedPajamaGithub


text:
namespace blink {

struct WebNavigationParams;
class WebURL;
class WebURLLoader;
class WebURLResponse;
struct WebURLError;

class WebURLLoaderMockFactory {
 public:
  static WebURLLoaderMockFactory* GetSingletonInstance();

  virtual ~WebURLLoaderMockFactory() = default;

  // Create a WebURLLoader that takes care of mocked requests.
  virtual std::unique_ptr<WebURLLoader> CreateURLLoader() = 0;

  // Registers a response and the file to be served when the specified URL
  // is loaded. If no file is specified then the response content will be empty.
  // UnregisterURL() should be called for each test entry before registering
  // another response for the same URL from another test.
  virtual void RegisterURL(const WebURL&,
                           const WebURLResponse&,
                           const WebString& file_path) = 0;

  // Registers an error to be served when the specified URL is requested.
  // UnregisterURL() should be called for each test entry before registering
  // another response for the same URL from another test.
  virtual void RegisterErrorURL(const WebURL&,
                                const WebURLResponse&,
                                const WebURLError&) = 0;

  // Unregisters the given URL so it is no longer mocked.
  virtual void UnregisterURL(const WebURL&) = 0;

  // Registers a response and the file to be served when a URL with the given
  // protocol is loaded. If no file is specified then the response content will
  // be empty. UnregisterProtocol() should be called for each test entry before
  // registering another response for the same protocol from another test.
  virtual void RegisterURLProtocol(const WebString& protocol,
                                   const WebURLResponse&,
                                   const WebString& file_path) = 0;

  // Unregisters the given URL protocol so it is no longer mocked.
  virtual void UnregisterURLProtocol(const WebString& protocol) = 0;

  // Unregisters URLs so they are no longer mocked. This also clears the
  // MemoryCache.
  virtual void UnregisterAllURLsAndClearMemoryCache() = 0;

  // Causes all pending asynchronous requests to be served. When this method
  // returns all the pending requests have been processed.
  // Note: this may not work as expected if more requests could be made
  // asynchronously from different threads (e.g. when HTML parser thread
  // is being involved).
  // DO NOT USE THIS for Frame loading; always use methods defined in
  // frame_test_helpers instead.
  virtual void ServeAsynchronousRequests() = 0;

  // Set a delegate that allows callbacks for all WebURLLoaderClients to be
  // intercepted.
  virtual void SetLoaderDelegate(WebURLLoaderTestDelegate*) = 0;

  // Fills navigation params by loading a mocked response.
  virtual void FillNavigationParamsResponse(WebNavigationParams*) = 0;
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_URL_LOADER_MOCK_FACTORY_H_


text:
MERGEABLES = (list, tuple, dict)

def merge(a, b):
    """Merge tuples, lists or dictionaries without duplicates
    """
    if isinstance(a, MERGEABLES) \
            and isinstance(b, MERGEABLES):
        # dict update
        if isinstance(a, dict) and isinstance(b, dict):
            a.update(b)
            return a
        # list update
        _a = list(a)
        for x in list(b):
            if x not in _a:
                _a.append(x)
        return _a
    if a and b:
        raise Exception("Cannot merge")
    raise NotImplementedError


text:
package VO;

public class PessoaVO {

	private String nome = null;
	private String cpf = null;
	private char sexo;
	private String endereco = null;

	public void setNome(String nome){
		this.nome = nome;
	}

	public String getNome(){
		return this.nome;
	}

	public void setCpf(String cpf){
		this.cpf = cpf;
	}

	public String getCpf(){
		return this.cpf;
	}

	public void setSexo(char sexo){
		this.sexo = sexo;
	}

	public char getSexo(){
		return this.sexo;
	}

	public void setEndereco(String endereco){
		this.endereco = endereco;
	}

	public String getEndereco(){
		return this.endereco;
	}

}


text:
namespace recomm_engine {
    namespace retrieving {

        class RetrievalHandler {
            public:
                RetrievalHandler();
                ~RetrievalHandler();

                int open();
                int retrieve(const idl::RetrievalRequest& request,
                        idl::RetrievalResponse* response);

            protected:
                void makeReply(idl::RetrievalResponse* response,
                        int doc_num, result_set* doc_set);

            protected:
                Ranker *m_ranker;   // compute score for per doc
        };
    }  // namespace retrieving
}  // namespace recomm_engine
#endif  // SRC_RETRIEVAL_RETRIEVAL_HANDLER_H_


text:
class CreateRepositories < ActiveRecord::Migration
  def change
    create_table :repositories do |t|
      t.string :name
      t.string :path
      t.references :user
      t.boolean :public

      t.timestamps
    end
    add_index :repositories, :path
    add_index :repositories, :user_id
  end
end


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">

  <title>Qt 4.3: Obsolete Members for QAbstractItemModel</title>
  <link href="classic.css" rel="stylesheet" type="text/css" />

  	Home · All Classes · Main Classes · Grouped Classes · Modules · Functions

Obsolete Members for QAbstractItemModel

The following class members are obsolete. They are provided to keep old source code working. We strongly advise against using them in new code.

QAbstractItemModel class reference

Protected Functions

QModelIndex createIndex ( int row, int column, int id ) const  <tt> (obsolete)</tt>

Member Function Documentation

QModelIndex QAbstractItemModel::createIndex ( int row, int column, int id ) const  <tt> [protected]</tt>

This is an overloaded member function, provided for convenience.

Use QModelIndex QAbstractItemModel::createIndex(int row, int column, quint32 id) instead.

<address>

Copyright © 2008 Trolltech
Trademarks

Qt 4.3.5

</address>


text:
class Comment < ApplicationRecord
  belongs_to :user
  belongs_to :juice
  validates :content, :user_id, :juice_id, presence: true
end


text:
  - Relax constraint on logstash-core-plugin-api to >= 1.60 <= 2.99

## 4.0.1
  - Republish all the gems under jruby.
## 4.0.0
  - Update the plugin to the version 2.0 of the plugin api, this change is required for Logstash 5.0 compatibility. See https://github.com/elastic/logstash/issues/5141
# 3.0.4
  - Depend on logstash-core-plugin-api instead of logstash-core, removing the need to mass update plugins on major releases of logstash
# 3.0.3
  - New dependency requirements for logstash-core for the 5.0 release
## 3.0.0
 - Plugins were updated to follow the new shutdown semantic, this mainly allows Logstash to instruct input plugins to terminate gracefully,
   instead of using Thread.raise on the plugins' threads. Ref: https://github.com/elastic/logstash/pull/3895
 - Dependency on logstash-core update to 2.0

# 1.0.1
  * Properly trim messages for AWS without breaking unicode byte boundaries

# 1.0.0
  * Full refactor.
  * This plugin now uses codecs for all formatting. The 'format' option has now been removed. Please use a codec.
# 0.1.5
  * If no `subject` are specified fallback to the %{host} key (https://github.com/logstash-plugins/logstash-output-sns/pull/2)
  * Migrate the SNS Api to use the AWS-SDK v2


text:
def generateIntAnalysisConfig(analysisName,outputTuple):
    """generateIntAnalysisConfig inputs name of analysis to perform and relevant information in output tuple and
    generates configuration files for downstream analyses."""

    # if performing multiple synteny analysis using SyntenyFinal
    if analysisName == 'syntenyAnalysis':
        open('syntenicConfig.txt','w').close()
        syntenicConfigFile = open('syntenicConfig.txt','w')

        syntenicConfigText = """NameAnalysis = %s
writeFastaOut = %s
Loci_Threshold = %s
pathPythonModules = %s
pathUnOut = %s
pathSort = %s
BPsMergeDist = %s
softMasked = %s
%s Test Analysis path = %s
%sStop

Fasta
genomePath = %s
listOfGenomeFiles:
%sStop"""%outputTuple
        syntenicConfigFile.write(syntenicConfigText)
        syntenicConfigFile.close()

    # if wishing to generate circos graphs
    if analysisName == 'circosAnalysis':
        open('circosFiguresPipelineConfig.txt', 'w').close()
        circosConfigFile = open('circosFiguresPipelineConfig.txt','w')

        circosConfigText = """# Circos Figures Config File Joshua Levy
faiFiles
%sStop
BedFiles
%sStop
faiFilePath = %s
karyotypesFilesPath = %s
BedInputPath = %s
circosConfigFilesPath = %s
LinkPath = %s
circosOutPath = %s
pathPythonModules = %s
BPsThreshold = %s"""%outputTuple
        circosConfigFile.write(circosConfigText)
        circosConfigFile.close()

    # if choosing to reconstruct a genome using allmaps and large syntenic segments, might not be as reliable as the
    #next option specified
    if analysisName == 'reconstructGenome':
        open('%sallMAPConfig.txt'%outputTuple[0],'w').close()
        allmapConfigFile = open('%sallMAPConfig.txt'%outputTuple[0],'w')
        allmapConfigText = """# Allmaps configuration file
pythonPath = %s
systemPath = %s
bedPath = %s
allMAPImageOutputPath = %s
fastaInputName = %s
fastaOutputName = %s
BedFileList
%sStop"""%outputTuple[1:]
        allmapConfigFile.write(allmapConfigText)
        allmapConfigFile.close()

    # does the same thing as the previous option, but instead of using large syntenic segments, uses small syntenic
    # genes to generate more data points for accurate build, recommended that this option is selected
    if analysisName == 'reconstructGenome2':
        open('%sallMAPConfig2.txt' % outputTuple[0], 'w').close()
        allmapConfigFile = open('%sallMAPConfig2.txt' % outputTuple[0], 'w')
        allmapConfigText = """# Allmaps configuration file
pythonPath = %s
systemPath = %s
bedPath = %s
allMAPImageOutputPath = %s
fastaInputName = %s
fastaOutputName = %s
UnOutPath = %s
SortPath = %s
loci_threshold = %s"""%outputTuple[1:]
        allmapConfigFile.write(allmapConfigText)
        allmapConfigFile.close()


text:
module Main where

import Control.Monad
-- import qualified Data.ByteString.Lazy as L
import System.Environment

import Data.IterIO
import Data.IterIO.Parse

iterio :: IO ()
iterio = do
  args <- getArgs
  forM_ args $ \arg -> do
           result <- enumFile' arg |$ p
           print (length result)
 where
  fast = many (while1I isLetter <|> while1I isDigit)
  isDigit c  = c >= eord '0' && c <= eord '9'
  isLetter c = (c >= eord 'a' && c <= eord 'z')
               || (c >= eord 'A' && c <= eord 'Z')
  p = fast

main :: IO ()
main = iterio


text:
This guide details how to get involved in EasyEngine commmunity. Please read this carefully.

## How to get help?

Please attach the output of following commands when opening a new support request.

```bash
lsb_release -a
ee cli version
ee cli info
wp --allow-root --info
```

### Where to create issue?

For free support, please use - http://community.rtcamp.com/c/easyengine

Please do NOT clutter GitHub issue tracker here with support requests. It hampers development speed of this project.

### Pull Requests

When submitting your code, please follow these coding standards - http://docs.rtcamp.com/easyengine/dev/python/

### EasyEngine Chat

Developers & contributors discussion: https://gitter.im/rtCamp/easyengine

Please do NOT use chat for technical support. Chat is limited to developers & contributors disucssion related to EasyEngine's future.


text:
{-# LANGUAGE CPP #-}
--------------------------------------------------------------------------------
--
-- Module    : MatrixMul
-- Copyright : (c) 2009 Trevor L. McDonell
-- License   : BSD
--
-- Matrix multiplication using runtime interface and execution control instead
-- of calling C functions via the FFI.
--
--------------------------------------------------------------------------------

module Main where

#include "matrix_mul.h"

-- Friends
import Time
import RandomVector

-- System
import Data.Array
import System.IO
import Foreign
import qualified Foreign.CUDA as CUDA

--------------------------------------------------------------------------------
-- Reference
--------------------------------------------------------------------------------

matMult :: (Num e, Storable e) => Matrix e -> Matrix e -> IO (Matrix e)
matMult mx my = do
  x <- unsafeFreeze mx
  y <- unsafeFreeze my
  let ((li, lj), (ui, uj))  = bounds x
      ((li',lj'),(ui',uj')) = bounds y
      resBnds | (lj,uj) == (li',ui') = ((li,lj'),(ui,uj'))
              | otherwise            = error "matrix dimensions must agree"

  newListArray resBnds [sum [x!(i,k) * y!(k,j) | k <- range (lj,uj)]
                         | i <- range (li,ui)
                         , j <- range (lj',uj') ]

--------------------------------------------------------------------------------
-- CUDA
--------------------------------------------------------------------------------

matMultCUDA :: (Num e, Storable e) => Matrix e -> Matrix e -> IO (Matrix e)
matMultCUDA xs' ys' = doMult undefined xs' ys'
  where
    doMult :: (Num e', Storable e') => e' -> Matrix e' -> Matrix e' -> IO (Matrix e')
    doMult dummy xs ys = do

      -- Setup matrix parameters
      --
      ((li, lj), (ui, uj))  <- getBounds xs
      ((li',lj'),(ui',uj')) <- getBounds ys
      let wx = rangeSize (lj,uj)
          hx = rangeSize (li,ui)
          wy = rangeSize (lj',uj')
          hy = rangeSize (li',ui')
          resBnds | wx == hy  = ((li,lj'),(ui,uj'))
                  | otherwise = error "matrix dimensions must agree"

      -- Allocate memory and copy test data
      --
      CUDA.allocaArray (wx*hx) $ \d_xs -> do
      CUDA.allocaArray (wy*hy) $ \d_ys -> do
      CUDA.allocaArray (wy*hx) $ \d_zs -> do
      withMatrix xs $ \p -> CUDA.pokeArray (wx*hx) p d_xs
      withMatrix ys $ \p -> CUDA.pokeArray (wy*hy) p d_ys

      -- Launch the kernel
      --
      let gridDim   = (wy`div`BLOCK_SIZE, hx`div`BLOCK_SIZE)
          blockDim  = (BLOCK_SIZE,BLOCK_SIZE,1)
          sharedMem = 2 * BLOCK_SIZE * BLOCK_SIZE * fromIntegral (sizeOf dummy)

      CUDA.setConfig gridDim blockDim sharedMem Nothing
      CUDA.setParams [CUDA.VArg d_xs, CUDA.VArg d_ys, CUDA.VArg d_zs, CUDA.IArg wx, CUDA.IArg wy]
      CUDA.launch "matrixMul"

      -- Copy back result
      zs <- newArray_ resBnds
      withMatrix zs $ \p -> CUDA.peekArray (wy*hx) d_zs p
      return zs

--------------------------------------------------------------------------------
-- Main
--------------------------------------------------------------------------------

main :: IO ()
main = do
  dev   <- CUDA.get
  props <- CUDA.props dev
  putStrLn $ "Using device " ++ show dev ++ ": " ++ CUDA.deviceName props

  xs <- randomArr ((1,1),(8*BLOCK_SIZE, 4*BLOCK_SIZE)) :: IO (Matrix Float)
  ys <- randomArr ((1,1),(4*BLOCK_SIZE,12*BLOCK_SIZE)) :: IO (Matrix Float)

  putStr   "== Reference: " >> hFlush stdout
  (tr,ref) <- benchmark 100 (matMult xs ys) (return ())
  putStrLn $  shows (fromInteger (timeIn millisecond tr) / 100::Float) " ms"

  putStr   "== CUDA: " >> hFlush stdout
  (tc,mat) <- benchmark 100 (matMultCUDA xs ys) (CUDA.sync)
  putStrLn $  shows (fromInteger (timeIn millisecond tc) / 100::Float) " ms"

  putStr "== Validating: "
  verify ref mat >>= \rv -> putStrLn $ if rv then "Ok!" else "INVALID!"


text:
package restlib.data;

import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import org.junit.Test;

import restlib.Response;

import com.google.common.testing.EqualsTester;
import com.google.common.testing.NullPointerTester;

public final class StatusTest {
	@Test
	public void testEquals() {
		new EqualsTester()
			.addEqualityGroup(Status.CLIENT_ERROR_BAD_REQUEST)
			.addEqualityGroup(Status.INFORMATIONAL_CONTINUE)
			.addEqualityGroup(Status.SERVER_ERROR_BAD_GATEWAY)
			.addEqualityGroup(Status.SUCCESS_ACCEPTED)
			.addEqualityGroup(Status.forCode(550), Status.forCode(550))
			.testEquals();
	}

	@Test
	public void testForCode_withInvalid() {
		try {
			Status.forCode(1000);
			fail("Expected IllegalArgumentException");
		} catch (final IllegalArgumentException expected){}

		try {
			Status.forCode(10);
			fail("Expected IllegalArgumentException");
		} catch (final IllegalArgumentException expected){}

		try {
			Status.forCode(-200);
			fail("Expected IllegalArgumentException");
		} catch (final IllegalArgumentException expected){}
	}

	@Test
	public void testNulls() {
		new NullPointerTester()
        	.testAllPublicInstanceMethods(Status.CLIENT_ERROR_BAD_REQUEST);
		new NullPointerTester()
			.testAllPublicStaticMethods(Status.class);
	}

	@Test
    public void testStatusClass() {
        for(final Status status : Status.REGISTERED_STATUSES.values()) {
            if (status.statusClass().equals(Status.Class.INFORMATIONAL)) {
                assertTrue((status.code() >= 100) && (status.code() < 200));
            } else if (status.statusClass().equals(Status.Class.SUCCESS)) {
                assertTrue((status.code() >= 200) && (status.code() < 300));
            } else if (status.statusClass().equals(Status.Class.REDIRECTION)) {
                assertTrue((status.code() >= 300) && (status.code() < 400));
            } else if (status.statusClass().equals(Status.Class.CLIENT_ERROR)) {
                assertTrue((status.code() >= 400) && (status.code() < 500));
            } else if (status.statusClass().equals(Status.Class.SERVER_ERROR)) {
                assertTrue((status.code() >= 500) && (status.code() < 600));
            } else {
                throw new RuntimeException("");
            }
        }
    }

    @Test
    public void testToResponse() {
    	for(final Status status : Status.REGISTERED_STATUSES.values()) {
            final Response response = status.toResponse();
            assertTrue(response.status().equals(status));
            assertTrue(response.entity().get().equals(status.message()));
        }
    }

}


text:
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models

class Migration(SchemaMigration):

    def forwards(self, orm):
        # Adding field 'Project.shared'
        db.add_column(u'api_project', 'shared',
                      self.gf('django.db.models.fields.BooleanField')(default=False),
                      keep_default=False)

    def backwards(self, orm):
        # Deleting field 'Project.shared'
        db.delete_column(u'api_project', 'shared')

    models = {
        'api.organizationprofile': {
            'Meta': {'object_name': 'OrganizationProfile', '_ormbases': ['main.UserProfile']},
            'creator': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
            'is_organization': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            u'userprofile_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['main.UserProfile']", 'unique': 'True', 'primary_key': 'True'})
        },
        'api.project': {
            'Meta': {'unique_together': "(('name', 'organization'),)", 'object_name': 'Project'},
            'created_by': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'project_creator'", 'to': u"orm['auth.User']"}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'date_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'metadata': ('jsonfield.fields.JSONField', [], {'default': '{}', 'null': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'organization': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'project_organization'", 'to': u"orm['auth.User']"}),
            'shared': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
        },
        'api.projectxform': {
            'Meta': {'unique_together': "(('xform', 'project'),)", 'object_name': 'ProjectXForm'},
            'created_by': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['api.Project']"}),
            'xform': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['logger.XForm']"})
        },
        'api.team': {
            'Meta': {'object_name': 'Team', '_ormbases': [u'auth.Group']},
            'created_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'team_creator'", 'null': 'True', 'to': u"orm['auth.User']"}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'null': 'True', 'blank': 'True'}),
            'date_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'null': 'True', 'blank': 'True'}),
            u'group_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['auth.Group']", 'unique': 'True', 'primary_key': 'True'}),
            'organization': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"}),
            'projects': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['api.Project']", 'symmetrical': 'False'})
        },
        u'auth.group': {
            'Meta': {'object_name': 'Group'},
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        u'auth.permission': {
            'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        u'auth.user': {
            'Meta': {'object_name': 'User'},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        u'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'logger.xform': {
            'Meta': {'ordering': "('id_string',)", 'unique_together': "(('user', 'id_string'), ('user', 'sms_id_string'))", 'object_name': 'XForm'},
            'allows_sms': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'bamboo_dataset': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '60'}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'date_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {'default': "u''", 'null': 'True'}),
            'downloadable': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'encrypted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'has_start_time': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'id_string': ('django.db.models.fields.SlugField', [], {'max_length': '100'}),
            'instances_with_geopoints': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'json': ('django.db.models.fields.TextField', [], {'default': "u''"}),
            'last_submission_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
            'num_of_submissions': ('django.db.models.fields.IntegerField', [], {'default': '-1'}),
            'shared': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'shared_data': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'sms_id_string': ('django.db.models.fields.SlugField', [], {'default': "''", 'max_length': '100'}),
            'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'xforms'", 'null': 'True', 'to': u"orm['auth.User']"}),
            'uuid': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '32'}),
            'xls': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True'}),
            'xml': ('django.db.models.fields.TextField', [], {})
        },
        'main.userprofile': {
            'Meta': {'object_name': 'UserProfile'},
            'address': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'city': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'country': ('django.db.models.fields.CharField', [], {'max_length': '2', 'blank': 'True'}),
            'created_by': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'}),
            'description': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'home_page': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'num_of_submissions': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
            'organization': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'phonenumber': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'require_auth': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'twitter': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'user': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'profile'", 'unique': 'True', 'to': u"orm['auth.User']"})
        },
        u'taggit.tag': {
            'Meta': {'object_name': 'Tag'},
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
            'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '100'})
        },
        u'taggit.taggeditem': {
            'Meta': {'object_name': 'TaggedItem'},
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'taggit_taggeditem_tagged_items'", 'to': u"orm['contenttypes.ContentType']"}),
            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'object_id': ('django.db.models.fields.IntegerField', [], {'db_index': 'True'}),
            'tag': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "u'taggit_taggeditem_items'", 'to': u"orm['taggit.Tag']"})
        }
    }

    complete_apps = ['api']


text:
package com.yz.dao;

import java.util.List;

import com.yz.model.Media;

public interface MediaDao {

	//保存一条记录
	void save(Media media);

	//保存一条记录
	Integer savereturn(Media media);

	//删除一条记录
	void delete(Media media);

	//根据ID删除一条记录
	void deleteById(int id);

	//修改一条记录
	void update(Media media);

	//根据hql语句、条件、条件值修改某些记录
	void updateByHql(final String hql,
			final String[] paramNames, final Object[] values);

	//获得所有记录
	List<Media> getMedias();

	//根据hql语句来查询所有记录
	List<Media> queryList(String queryString);

	//根据hql、条件值查询某些记录
	List<Media> getObjectsByCondition(String queryString,
			Object[] p);

	//根据hql语句、条件、条件值查询某些记录
	List<Media> queryList(String queryString,
			String[] paramNames, Object[] values);

	//根据hql、id列表查询某些记录
	List<Media> getObjectsByIdList(final String hql,
			final List<Integer> idList);

	//根据hql语句、条件值、分页查询某些记录
	List<Media> pageList(final String queryString,
			final Object[] p, final Integer page, final Integer size);

	//根据hql、条件值获得一个唯一值
	int getUniqueResult(final String queryString,
			final Object[] p);

	//根据id查询一条记录
	Media loadById(int id);

	//根据hql语句、条件、值来查询一条记录
	Media queryByNamedParam(String queryString,
			String[] paramNames, Object[] values);

	//根据hql语句、条件值来查询是否存在该记录
	boolean checkMediaExistsWithName(String queryString,
			Object[] p);

	//根据hql批量修改
	int updateMediaByhql(String queryString, Object[] p);

	Media getMediaById(Integer upmediaid);

}


text:
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

cd "${DIR}/.."
source "${DIR}/apollo_base.sh"

python ./modules/tools/control_info/control_info.py $@


text:
package xlog

import (
	"fmt"
	"time"

	"context"

	"github.com/speedland/go/x/xruntime"
	"github.com/speedland/go/x/xtime"
)

// Record is a data set for one log line/data
type Record struct {
	Timestamp time.Time
	Data      interface{}

	Level Level // Log Levell

	LoggerKey interface{}       // Logger Key
	Stack     []*xruntime.Frame // Log Source BenchmarkLoggerFewStackCapture

	ctx context.Context // used for application context
}

// Context returns context.Context associated with the record.
func (r *Record) Context() context.Context {
	return r.ctx
}

// ContextValue returns the context value
func (r *Record) ContextValue(key interface{}) interface{} {
	if r.ctx != nil {
		return r.ctx.Value(key)
	}
	return nil
}

// Option is option fields for logger.
type Option struct {
	MinStackCaptureOn Level // Minimum Level where logger captures stacks. Strongly recommend to set LevelFatal.
	StackCaptureDepth int   // # of stack frames to be captured on logging.
}

// Logger the logger
type Logger struct {
	*Option
	key    interface{}
	sink   Sink
	ctx    context.Context
	prefix string
}

// New returns a new Logger instance.
func New(s Sink) *Logger {
	option := new(Option)
	*option = *defaultOption // copy default option
	caller := xruntime.CaptureCaller()
	return &Logger{
		Option: option,
		sink:   s,
		key:    caller.PackageName,
		ctx:    nil,
	}
}

// WithContext returns a shallow copy of Logger with its context changed to ctx.
// The provided ctx must be non-nil.
func (l *Logger) WithContext(ctx context.Context) *Logger {
	if ctx == nil {
		panic("nil context")
	}
	l2 := new(Logger)
	*l2 = *l
	l2.ctx = ctx
	return l2
}

// WithKey returns a shallow copy of Logger with its key changed to `key`.
func (l *Logger) WithKey(key interface{}) *Logger {
	l2 := new(Logger)
	*l2 = *l
	l2.key = key
	return l2
}

// Tracef to write text log with LevelTrace
func (l *Logger) Tracef(s string, v ...interface{}) {
	l.write(LevelTrace, l.format(s, v...))
}

// Trace to write data log with LevelTrace
func (l *Logger) Trace(v interface{}) {
	l.write(LevelTrace, v)
}

// Debugf to write text log with LevelDebug
func (l *Logger) Debugf(s string, v ...interface{}) {
	l.write(LevelDebug, l.format(s, v...))
}

// Debug to write data log with LevelDebug
func (l *Logger) Debug(v interface{}) {
	l.write(LevelDebug, v)
}

// Infof to write text log with LevelInfo
func (l *Logger) Infof(s string, v ...interface{}) {
	l.write(LevelInfo, l.format(s, v...))
}

// Info to write data log with LevelInfo
func (l *Logger) Info(v interface{}) {
	l.write(LevelInfo, v)
}

// Warnf to write text log with LevelWarn
func (l *Logger) Warnf(s string, v ...interface{}) {
	l.write(LevelWarn, l.format(s, v...))
}

// Warn to write data log with LevelWarn
func (l *Logger) Warn(v interface{}) {
	l.write(LevelWarn, v)
}

// Errorf to write text log with LevelError
func (l *Logger) Errorf(s string, v ...interface{}) {
	l.write(LevelError, l.format(s, v...))
}

// Error to write data log with LevelError
func (l *Logger) Error(v interface{}) {
	l.write(LevelError, v)
}

// Fatalf to write text log with LevelTrace
func (l *Logger) Fatalf(s string, v ...interface{}) {
	l.write(LevelFatal, l.format(s, v...))
}

// Fatal to write text log with LevelFatal
func (l *Logger) Fatal(v interface{}) {
	l.write(LevelFatal, v)
}

func (l *Logger) format(s string, v ...interface{}) string {
	if l.prefix == "" {
		return fmt.Sprintf(s, v...)
	}
	return fmt.Sprintf("%s%s", l.prefix, fmt.Sprintf(s, v...))
}

func (l *Logger) write(level Level, data interface{}) {
	if v, ok := data.(func(*Printer)); ok {
		data = printerFunc(v)
	}
	r := &Record{
		Level:     level,
		Data:      data,
		Timestamp: xtime.Now(),
		LoggerKey: l.key,
		ctx:       l.ctx,
	}
	if l.MinStackCaptureOn <= r.Level {
		r.Stack = xruntime.CaptureStackFrom(2, l.StackCaptureDepth)
	}
	l.sink.Write(r)
}


text:
package client

import (
	"context"

	"github.com/tidepool-org/platform/client"
	"github.com/tidepool-org/platform/errors"
	"github.com/tidepool-org/platform/oauth"
	"github.com/tidepool-org/platform/request"
)

type Client struct {
	client            *client.Client
	tokenSourceSource oauth.TokenSourceSource
}

func New(config *client.Config, tokenSourceSource oauth.TokenSourceSource) (*Client, error) {
	if config == nil {
		return nil, errors.New("config is missing")
	}
	if tokenSourceSource == nil {
		return nil, errors.New("token source source is missing")
	}

	clnt, err := client.New(config)
	if err != nil {
		return nil, err
	}

	return &Client{
		client:            clnt,
		tokenSourceSource: tokenSourceSource,
	}, nil
}

func (c *Client) ConstructURL(paths ...string) string {
	return c.client.ConstructURL(paths...)
}

func (c *Client) AppendURLQuery(urlString string, query map[string]string) string {
	return c.client.AppendURLQuery(urlString, query)
}

func (c *Client) SendOAuthRequest(ctx context.Context, method string, url string, mutators []request.RequestMutator, requestBody interface{}, responseBody interface{}, httpClientSource oauth.HTTPClientSource) error {
	if httpClientSource == nil {
		return errors.New("http client source is missing")
	}

	httpClient, err := httpClientSource.HTTPClient(ctx, c.tokenSourceSource)
	if err != nil {
		return err
	}

	return c.client.RequestDataWithHTTPClient(ctx, method, url, mutators, requestBody, responseBody, nil, httpClient)
}


text:
<?php
  $title       = 'Making Programming Simpler | Robot2';
  $description = 'Keep it extremely simple, \'cause code is mostly for humans, computers only cares about machine code.';
?>

<?php include("partials/head.php"); ?>

  <?php include("partials/navigation.php"); ?>

Keep it extremely simple

Complexity is the enemy of productivity.
           Shorter code with fewer moving parts is simpler to read and test,
           so as a developer my job is to simplify.
           Write code that works exactly as expected, is performant, is easy to understand
           and doesn't take too long to implement.

    	<?php include("partials/get-in-touch.php"); ?>

<?php include("partials/footer.php"); ?>


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Syn. meth. fung. (Göttingen) 2: 538 (1801)

#### Original name
Boletus pomaceus Pers., 1800

### Remarks
null


text:
var assert = require('assert');
var nock = require('nock');

var Gdax = require('../index.js');

var key = 'key';
var secret = 'secret';
var passphrase = 'passphrase';

var testserver = require('./lib/ws_testserver');
var port = 56632;

suite('WebsocketClient');

describe('WebsocketClient', function() {
  test('connects to specified server', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient(['BTC-EUR'], 'ws://localhost:' + port);
      websocketClient.on('open', function() {
        server.close();
        done();
      });
    });
  });

  test('subscribes to the default product (BTC-USD) if undefined', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient(null, 'ws://localhost:' + port);
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.deepEqual(msg, {
          type: 'subscribe',
          product_ids: ['BTC-USD']
        });

        server.close();
        done();
      });
    });
  });

  test('subscribes to the default product (BTC-USD) if empty string', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient('', 'ws://localhost:' + port);
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.deepEqual(msg, {
          type: 'subscribe',
          product_ids: ['BTC-USD']
        });

        server.close();
        done();
      });
    });
  });

  test('subscribes to the default product (BTC-USD) if empty array passed', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient([], 'ws://localhost:' + port);
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.deepEqual(msg, {
          type: 'subscribe',
          product_ids: ['BTC-USD']
        });

        server.close();
        done();
      });
    });
  });

  test('subscribes to the specified products', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient(['BTC-EUR'], 'ws://localhost:' + port);
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.deepEqual(msg, {
          type: 'subscribe',
          product_ids: ['BTC-EUR']
        });

        server.close();
        done();
      });
    });
  });

  test('subscribes to the specified product (backward compatibility)', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient('ETH-USD', 'ws://localhost:' + port);
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.deepEqual(msg, {
          type: 'subscribe',
          product_ids: ['ETH-USD']
        });

        server.close();
        done();
      });
    });
  });

  test('passes authentication details through', function(done) {
    var server = testserver(++port, function() {
      var websocketClient = new Gdax.WebsocketClient('ETH-USD', 'ws://localhost:' + port, {
        key: 'suchkey',
        secret: 'suchsecret',
        passphrase: 'muchpassphrase'
      });
    });
    server.on('connection', function(socket) {
      socket.on('message', function(data) {
        var msg = JSON.parse(data);
        assert.equal(msg.type, 'subscribe');
        assert.equal(msg.key, 'suchkey');
        assert.equal(msg.passphrase, 'muchpassphrase');
        assert(msg.timestamp);
        assert(msg.signature);

        server.close();
        done();
      });
    });
  });
});


text:
/*
 * Resource for capturing binary data
 *
 * [FhirResource("Binary")]
 * [Serializable]
 */

#import "FHIRBaseResource.h"

@class FHIRBase64Binary;
@class FHIRString;

@interface FHIRBinary : FHIRBaseResource

/*
 * Binary contents
 */
@property (nonatomic, strong) FHIRBase64Binary *contentElement;

@property (nonatomic, strong) NSData *content;

/*
 * Media type of contents
 */
@property (nonatomic, strong) FHIRString *contentTypeElement;

@property (nonatomic, strong) NSString *contentType;

- (FHIRErrorList *)validate;

@end


text:
package org.docksidestage.mysql.dbflute.bsentity;

import java.util.List;
import java.util.ArrayList;

import org.dbflute.Entity;
import org.dbflute.dbmeta.DBMeta;
import org.dbflute.dbmeta.AbstractEntity;
import org.dbflute.dbmeta.accessory.DomainEntity;
import org.dbflute.optional.OptionalEntity;
import org.docksidestage.mysql.dbflute.allcommon.DBMetaInstanceHandler;
import org.docksidestage.mysql.dbflute.allcommon.CDef;
import org.docksidestage.mysql.dbflute.exentity.*;

/**
 * The entity of (VIEW)SUMMARY_PRODUCT as VIEW.

 *

 * [primary-key]
 *     PRODUCT_ID
 *
 * [column]
 *     PRODUCT_ID, PRODUCT_NAME, PRODUCT_HANDLE_CODE, PRODUCT_STATUS_CODE, LATEST_PURCHASE_DATETIME
 *
 * [sequence]
 *
 *
 * [identity]
 *
 *
 * [version-no]
 *
 *
 * [foreign table]
 *     PRODUCT_STATUS
 *
 * [referrer table]
 *     PURCHASE
 *
 * [foreign property]
 *     productStatus
 *
 * [referrer property]
 *     purchaseList
 *
 * [get/set template]
 * /= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
 * Integer productId = entity.getProductId();
 * String productName = entity.getProductName();
 * String productHandleCode = entity.getProductHandleCode();
 * String productStatusCode = entity.getProductStatusCode();
 * java.time.LocalDateTime latestPurchaseDatetime = entity.getLatestPurchaseDatetime();
 * entity.setProductId(productId);
 * entity.setProductName(productName);
 * entity.setProductHandleCode(productHandleCode);
 * entity.setProductStatusCode(productStatusCode);
 * entity.setLatestPurchaseDatetime(latestPurchaseDatetime);
 * = = = = = = = = = =/
 *

 * @author DBFlute(AutoGenerator)
 */
public abstract class BsSummaryProduct extends AbstractEntity implements DomainEntity {

    // ===================================================================================
    //                                                                          Definition
    //                                                                          ==========
    /** The serial version UID for object serialization. (Default) */
    private static final long serialVersionUID = 1L;

    // ===================================================================================
    //                                                                           Attribute
    //                                                                           =========
    /** (商品ID)PRODUCT_ID: {PK, NotNull, INT(10), default=[0]} */
    protected Integer _productId;

    /** (商品名称)PRODUCT_NAME: {NotNull, VARCHAR(50)} */
    protected String _productName;

    /** (商品ハンドルコード)PRODUCT_HANDLE_CODE: {UQ, NotNull, VARCHAR(100)} */
    protected String _productHandleCode;

    /** PRODUCT_STATUS_CODE: {NotNull, CHAR(3), FK to PRODUCT_STATUS, classification=ProductStatus} */
    protected String _productStatusCode;

    /** LATEST_PURCHASE_DATETIME: {DATETIME(19)} */
    protected java.time.LocalDateTime _latestPurchaseDatetime;

    // ===================================================================================
    //                                                                             DB Meta
    //                                                                             =======
    /** {@inheritDoc} */
    public DBMeta asDBMeta() {
        return DBMetaInstanceHandler.findDBMeta(asTableDbName());
    }

    /** {@inheritDoc} */
    public String asTableDbName() {
        return "summary_product";
    }

    // ===================================================================================
    //                                                                        Key Handling
    //                                                                        ============
    /** {@inheritDoc} */
    public boolean hasPrimaryKeyValue() {
        if (_productId == null) { return false; }
        return true;
    }

    /**
     * To be unique by the unique column.

     * You can update the entity by the key when entity update (NOT batch update).
     * @param productHandleCode (商品ハンドルコード): UQ, NotNull, VARCHAR(100). (NotNull)
     */
    public void uniqueBy(String productHandleCode) {
        __uniqueDrivenProperties.clear();
        __uniqueDrivenProperties.addPropertyName("productHandleCode");
        setProductHandleCode(productHandleCode);
    }

    // ===================================================================================
    //                                                             Classification Property
    //                                                             =======================
    /**
     * Get the value of productStatusCode as the classification of ProductStatus.

     * PRODUCT_STATUS_CODE: {NotNull, CHAR(3), FK to PRODUCT_STATUS, classification=ProductStatus}

     * 商品ステータス: 商品の状態を示す
     *
It's treated as case insensitive and if the code value is null, it returns null.

     * @return The instance of classification definition (as ENUM type). (NullAllowed: when the column value is null)
     */
    public CDef.ProductStatus getProductStatusCodeAsProductStatus() {
        return CDef.ProductStatus.of(getProductStatusCode()).orElse(null);
    }

    /**
     * Set the value of productStatusCode as the classification of ProductStatus.

     * PRODUCT_STATUS_CODE: {NotNull, CHAR(3), FK to PRODUCT_STATUS, classification=ProductStatus}

     * 商品ステータス: 商品の状態を示す
     * @param cdef The instance of classification definition (as ENUM type). (NullAllowed: if null, null value is set to the column)
     */
    public void setProductStatusCodeAsProductStatus(CDef.ProductStatus cdef) {
        setProductStatusCode(cdef != null ? cdef.code() : null);
    }

    // ===================================================================================
    //                                                              Classification Setting
    //                                                              ======================
    /**
     * Set the value of productStatusCode as OnSale (ONS).

     * 生産販売可能
     */
    public void setProductStatusCode_OnSale() {
        setProductStatusCodeAsProductStatus(CDef.ProductStatus.OnSale);
    }

    /**
     * Set the value of productStatusCode as ProductStop (PST).

     * 生産中止
     */
    public void setProductStatusCode_ProductStop() {
        setProductStatusCodeAsProductStatus(CDef.ProductStatus.ProductStop);
    }

    /**
     * Set the value of productStatusCode as SaleStop (SST).

     * 販売中止
     */
    public void setProductStatusCode_SaleStop() {
        setProductStatusCodeAsProductStatus(CDef.ProductStatus.SaleStop);
    }

    // ===================================================================================
    //                                                        Classification Determination
    //                                                        ============================
    /**
     * Is the value of productStatusCode OnSale?

     * 生産販売可能
     *
It's treated as case insensitive and if the code value is null, it returns false.

     * @return The determination, true or false.
     */
    public boolean isProductStatusCodeOnSale() {
        CDef.ProductStatus cdef = getProductStatusCodeAsProductStatus();
        return cdef != null ? cdef.equals(CDef.ProductStatus.OnSale) : false;
    }

    /**
     * Is the value of productStatusCode ProductStop?

     * 生産中止
     *
It's treated as case insensitive and if the code value is null, it returns false.

     * @return The determination, true or false.
     */
    public boolean isProductStatusCodeProductStop() {
        CDef.ProductStatus cdef = getProductStatusCodeAsProductStatus();
        return cdef != null ? cdef.equals(CDef.ProductStatus.ProductStop) : false;
    }

    /**
     * Is the value of productStatusCode SaleStop?

     * 販売中止
     *
It's treated as case insensitive and if the code value is null, it returns false.

     * @return The determination, true or false.
     */
    public boolean isProductStatusCodeSaleStop() {
        CDef.ProductStatus cdef = getProductStatusCodeAsProductStatus();
        return cdef != null ? cdef.equals(CDef.ProductStatus.SaleStop) : false;
    }

    // ===================================================================================
    //                                                           Classification Name/Alias
    //                                                           =========================
    /**
     * Get the value of the column 'productStatusCode' as classification name.
     * @return The string of classification name. (NullAllowed: when the column value is null)
     */
    public String getProductStatusCodeName() {
        CDef.ProductStatus cdef = getProductStatusCodeAsProductStatus();
        return cdef != null ? cdef.name() : null;
    }

    /**
     * Get the value of the column 'productStatusCode' as classification alias.
     * @return The string of classification alias. (NullAllowed: when the column value is null)
     */
    public String getProductStatusCodeAlias() {
        CDef.ProductStatus cdef = getProductStatusCodeAsProductStatus();
        return cdef != null ? cdef.alias() : null;
    }

    // ===================================================================================
    //                                                                    Foreign Property
    //                                                                    ================
    /** (商品ステータス)PRODUCT_STATUS by my PRODUCT_STATUS_CODE, named 'productStatus'. */
    protected OptionalEntity<ProductStatus> _productStatus;

    /**
     * [get] (商品ステータス)PRODUCT_STATUS by my PRODUCT_STATUS_CODE, named 'productStatus'.

     * Optional: alwaysPresent(), ifPresent().orElse(), get(), ...
     * @return The entity of foreign property 'productStatus'. (NotNull, EmptyAllowed: when e.g. null FK column, no setupSelect)
     */
    public OptionalEntity<ProductStatus> getProductStatus() {
        if (_productStatus == null) { _productStatus = OptionalEntity.relationEmpty(this, "productStatus"); }
        return _productStatus;
    }

    /**
     * [set] (商品ステータス)PRODUCT_STATUS by my PRODUCT_STATUS_CODE, named 'productStatus'.
     * @param productStatus The entity of foreign property 'productStatus'. (NullAllowed)
     */
    public void setProductStatus(OptionalEntity<ProductStatus> productStatus) {
        _productStatus = productStatus;
    }

    // ===================================================================================
    //                                                                   Referrer Property
    //                                                                   =================
    /** (購入)PURCHASE by PRODUCT_ID, named 'purchaseList'. */
    protected List<Purchase> _purchaseList;

    /**
     * [get] (購入)PURCHASE by PRODUCT_ID, named 'purchaseList'.
     * @return The entity list of referrer property 'purchaseList'. (NotNull: even if no loading, returns empty list)
     */
    public List<Purchase> getPurchaseList() {
        if (_purchaseList == null) { _purchaseList = newReferrerList(); }
        return _purchaseList;
    }

    /**
     * [set] (購入)PURCHASE by PRODUCT_ID, named 'purchaseList'.
     * @param purchaseList The entity list of referrer property 'purchaseList'. (NullAllowed)
     */
    public void setPurchaseList(List<Purchase> purchaseList) {
        _purchaseList = purchaseList;
    }

    protected <ELEMENT> List<ELEMENT> newReferrerList() { // overriding to import
        return new ArrayList<ELEMENT>();
    }

    // ===================================================================================
    //                                                                      Basic Override
    //                                                                      ==============
    @Override
    protected boolean doEquals(Object obj) {
        if (obj instanceof BsSummaryProduct) {
            BsSummaryProduct other = (BsSummaryProduct)obj;
            if (!xSV(_productId, other._productId)) { return false; }
            return true;
        } else {
            return false;
        }
    }

    @Override
    protected int doHashCode(int initial) {
        int hs = initial;
        hs = xCH(hs, asTableDbName());
        hs = xCH(hs, _productId);
        return hs;
    }

    @Override
    protected String doBuildStringWithRelation(String li) {
        StringBuilder sb = new StringBuilder();
        if (_productStatus != null && _productStatus.isPresent())
        { sb.append(li).append(xbRDS(_productStatus, "productStatus")); }
        if (_purchaseList != null) { for (Purchase et : _purchaseList)
        { if (et != null) { sb.append(li).append(xbRDS(et, "purchaseList")); } } }
        return sb.toString();
    }
    protected <ET extends Entity> String xbRDS(org.dbflute.optional.OptionalEntity<ET> et, String name) { // buildRelationDisplayString()
        return et.get().buildDisplayString(name, true, true);
    }

    @Override
    protected String doBuildColumnString(String dm) {
        StringBuilder sb = new StringBuilder();
        sb.append(dm).append(xfND(_productId));
        sb.append(dm).append(xfND(_productName));
        sb.append(dm).append(xfND(_productHandleCode));
        sb.append(dm).append(xfND(_productStatusCode));
        sb.append(dm).append(xfND(_latestPurchaseDatetime));
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    @Override
    protected String doBuildRelationString(String dm) {
        StringBuilder sb = new StringBuilder();
        if (_productStatus != null && _productStatus.isPresent())
        { sb.append(dm).append("productStatus"); }
        if (_purchaseList != null && !_purchaseList.isEmpty())
        { sb.append(dm).append("purchaseList"); }
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length()).insert(0, "(").append(")");
        }
        return sb.toString();
    }

    @Override
    public SummaryProduct clone() {
        return (SummaryProduct)super.clone();
    }

    // ===================================================================================
    //                                                                            Accessor
    //                                                                            ========
    /**
     * [get] (商品ID)PRODUCT_ID: {PK, NotNull, INT(10), default=[0]}

     * @return The value of the column 'PRODUCT_ID'. (basically NotNull if selected: for the constraint)
     */
    public Integer getProductId() {
        checkSpecifiedProperty("productId");
        return _productId;
    }

    /**
     * [set] (商品ID)PRODUCT_ID: {PK, NotNull, INT(10), default=[0]}

     * @param productId The value of the column 'PRODUCT_ID'. (basically NotNull if update: for the constraint)
     */
    public void setProductId(Integer productId) {
        registerModifiedProperty("productId");
        _productId = productId;
    }

    /**
     * [get] (商品名称)PRODUCT_NAME: {NotNull, VARCHAR(50)}

     * @return The value of the column 'PRODUCT_NAME'. (basically NotNull if selected: for the constraint)
     */
    public String getProductName() {
        checkSpecifiedProperty("productName");
        return _productName;
    }

    /**
     * [set] (商品名称)PRODUCT_NAME: {NotNull, VARCHAR(50)}

     * @param productName The value of the column 'PRODUCT_NAME'. (basically NotNull if update: for the constraint)
     */
    public void setProductName(String productName) {
        registerModifiedProperty("productName");
        _productName = productName;
    }

    /**
     * [get] (商品ハンドルコード)PRODUCT_HANDLE_CODE: {UQ, NotNull, VARCHAR(100)}

     * 商品を識別する業務上のコード。
     * @return The value of the column 'PRODUCT_HANDLE_CODE'. (basically NotNull if selected: for the constraint)
     */
    public String getProductHandleCode() {
        checkSpecifiedProperty("productHandleCode");
        return _productHandleCode;
    }

    /**
     * [set] (商品ハンドルコード)PRODUCT_HANDLE_CODE: {UQ, NotNull, VARCHAR(100)}

     * 商品を識別する業務上のコード。
     * @param productHandleCode The value of the column 'PRODUCT_HANDLE_CODE'. (basically NotNull if update: for the constraint)
     */
    public void setProductHandleCode(String productHandleCode) {
        registerModifiedProperty("productHandleCode");
        _productHandleCode = productHandleCode;
    }

    /**
     * [get] PRODUCT_STATUS_CODE: {NotNull, CHAR(3), FK to PRODUCT_STATUS, classification=ProductStatus}

     * @return The value of the column 'PRODUCT_STATUS_CODE'. (basically NotNull if selected: for the constraint)
     */
    public String getProductStatusCode() {
        checkSpecifiedProperty("productStatusCode");
        return _productStatusCode;
    }

    /**
     * [set] PRODUCT_STATUS_CODE: {NotNull, CHAR(3), FK to PRODUCT_STATUS, classification=ProductStatus}

     * @param productStatusCode The value of the column 'PRODUCT_STATUS_CODE'. (basically NotNull if update: for the constraint)
     */
    protected void setProductStatusCode(String productStatusCode) {
        checkClassificationCode("PRODUCT_STATUS_CODE", CDef.DefMeta.ProductStatus, productStatusCode);
        registerModifiedProperty("productStatusCode");
        _productStatusCode = productStatusCode;
    }

    /**
     * [get] LATEST_PURCHASE_DATETIME: {DATETIME(19)}

     * @return The value of the column 'LATEST_PURCHASE_DATETIME'. (NullAllowed even if selected: for no constraint)
     */
    public java.time.LocalDateTime getLatestPurchaseDatetime() {
        checkSpecifiedProperty("latestPurchaseDatetime");
        return _latestPurchaseDatetime;
    }

    /**
     * [set] LATEST_PURCHASE_DATETIME: {DATETIME(19)}

     * @param latestPurchaseDatetime The value of the column 'LATEST_PURCHASE_DATETIME'. (NullAllowed: null update allowed for no constraint)
     */
    public void setLatestPurchaseDatetime(java.time.LocalDateTime latestPurchaseDatetime) {
        registerModifiedProperty("latestPurchaseDatetime");
        _latestPurchaseDatetime = latestPurchaseDatetime;
    }

    /**
     * For framework so basically DON'T use this method.
     * @param productStatusCode The value of the column 'PRODUCT_STATUS_CODE'. (basically NotNull if update: for the constraint)
     */
    public void mynativeMappingProductStatusCode(String productStatusCode) {
        setProductStatusCode(productStatusCode);
    }
}


text:
<?php

namespace s9e\TextFormatter\Configurator\Items\AttributeFilters;

use s9e\TextFormatter\Configurator\Items\AttributeFilter;

class EmailFilter extends AttributeFilter
{
	/**
	* Constructor
	*/
	public function __construct()
	{
		parent::__construct('s9e\\TextFormatter\\Parser\\AttributeFilters\\EmailFilter::filter');
		$this->setJS('EmailFilter.filter');
	}
}


text: Exciting Real Estate Company


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:draggable_panel="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:animateLayoutChanges="true"
    android:fitsSystemWindows="true"
    tools:mContext="bj.vinylbrowser.main.MainActivity"
    >

    <FrameLayout
        android:id="@+id/lytContent"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

    <com.github.pedrovgs.DraggablePanel
        android:id="@+id/draggable_panel"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        draggable_panel:enable_horizontal_alpha_effect="false"
        draggable_panel:top_fragment_height="200dp"/>

</RelativeLayout>


text:
Timer::Timer()
{
	m_nFrequency.QuadPart = FREQ_DEFAULT_VALUE;
	m_nStartTime.QuadPart = 0;
	m_nStopTime.QuadPart = 0;
	QueryPerformanceFrequency(&m_nFrequency);
}

Timer::~Timer()
{
}

void Timer::start()
{
	QueryPerformanceCounter(&m_nStartTime);
}

void Timer::stop()
{
	QueryPerformanceCounter(&m_nStopTime);
}

unsigned int Timer::getElapse()
{

}
unsigned int Timer::getElapseMicrosecond()
unsigned int Timer::getElapseFrequency()
unsigned int Timer::getInterval()


text:
Mecha Lady Shogi
===========================

A Mecha Lady Shogi program: Julia based Japanese Chess (Shogi) Engine

This Japanese Chess Engine works with
the "Shogi Dokoro" Shogi UI frontend system.

--------------------------------------------------

About This Project

--------------------------------------------------

* Julia language based Japanese Chess Engine
* (Currently) weak Shogi playing ability
* Your pull-requests are welcome!
* Tested only in Linux (not yet tested in Windows and MacOSX)

==================================================

How to Install
--------------------------------------------------

1. Install these software dependencies:
      * Julia programming language (of course!)
      * mono (for running Shogi Dokoro)
      * Shogi Dokoro Shogi User Interface
      * Gnu Make
      * Gnu C
2. Clone this project.
3. In project directory, run the following command: `make sharedlib`
4. Run the Shogi Dokoro UI Interface: `mono Shogidokoro.exe`

How to Play
--------------------------------------------------

Run the Shogi Dokoro UI and register Julia/Main.jl as the Shogi Engine.
Please add "#!/your/Julia/executable/path" to the top of Julia/Main.jl.
For example: #!/home/kimrin/julia-master/julia

(Before registering the Shogi Engine, comment out Main.jl's "please commented out when registration"
require command lines, and register. After registration, uncomment these lines.)

A necessary file `fv.bin` is not in our repository,
due to a different distribution license.

Please download a recent "Bonanza" Shogi program and copy the file `fv.bin` into this directory.

I'll describe how to play using Shogi Dokoro UI later...

License
--------------------------------------------------
MIT License