text:
package br.site.model.entity;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.validation.constraints.NotNull;

import org.hibernate.annotations.Type;

@NamedQueries({
	@NamedQuery(name = "Noticia.findNoticiasByUsuarioId", query = "select n from Noticia n where n.usuario.id=:id"),
	@NamedQuery(name = "Noticia.findNoticiasBySecao", query = "select n from Noticia n where n.secao.titulo=:titulo"),
	@NamedQuery(name = "Noticia.findNoticiaWithComentarios", query = "select n from Noticia n left join fetch n.comentarios where n.id = :id")
})
@Entity
public class Noticia {

	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	@NotNull(message = "Digite o titulo da noticia")
	private String titulo;
	@NotNull(message = "Digite o subtitulo da noticia")
	private String subtitulo;
	@NotNull(message = "Digite a descricao da noticia")
	private String descricao;
	@Type(type = "org.hibernate.type.BinaryType")
	private byte[] imagem;
	@Temporal(TemporalType.TIMESTAMP)
	private Date dataPostagem;

	@ManyToOne
	@JoinColumn(name = "secao_id")
	private Secao secao;

	@ManyToOne
	@JoinColumn(name = "usuario_id")
	private Usuario usuario;

	@OneToMany(mappedBy = "noticia", cascade = CascadeType.ALL)
	private List<Comentario> comentarios;

	public Noticia() {

	}

	public Noticia(String titulo, String subtitulo, String descricao,
			byte[] imagem, Date dataPostagem, Secao secao, Usuario usuario,
			List<Comentario> comentarios) {
		this.titulo = titulo;
		this.subtitulo = subtitulo;
		this.descricao = descricao;
		this.imagem = imagem;
		this.dataPostagem = dataPostagem;
		this.secao = secao;
		this.usuario = usuario;
		this.comentarios = comentarios;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getTitulo() {
		return titulo;
	}

	public void setTitulo(String titulo) {
		this.titulo = titulo;
	}

	public String getSubtitulo() {
		return subtitulo;
	}

	public void setSubtitulo(String subtitulo) {
		this.subtitulo = subtitulo;
	}

	public String getDescricao() {
		return descricao;
	}

	public void setDescricao(String descricao) {
		this.descricao = descricao;
	}

	public byte[] getImagem() {
		return imagem;
	}

	public void setImagem(byte[] imagem) {
		this.imagem = imagem;
	}

	public Date getDataPostagem() {
		return dataPostagem;
	}

	public void setDataPostagem(Date dataPostagem) {
		this.dataPostagem = dataPostagem;
	}

	public Secao getSecao() {
		return secao;
	}

	public void setSecao(Secao secao) {
		this.secao = secao;
	}

	public Usuario getUsuario() {
		return usuario;
	}

	public void setUsuario(Usuario usuario) {
		this.usuario = usuario;
	}

	public List<Comentario> getComentarios() {
		return comentarios;
	}

	public void setComentarios(List<Comentario> comentarios) {
		this.comentarios = comentarios;
	}

	@Override
	public String toString() {
		return "Noticia [id=" + id + ", titulo=" + titulo + ", subTitulo="
				+ subtitulo + ", descricao=" + descricao + ", imagem="
				+ Arrays.toString(imagem) + ", dataPostagem=" + dataPostagem
				+ ", secao=" + secao + ", usuario=" + usuario
				+ ", comentarios=" + comentarios + "]";
	}

}


text:
"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _typeof = require("@babel/runtime/helpers/typeof");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CheckboxGroup = void 0;

var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _xor = _interopRequireDefault(require("lodash/xor"));

var _react = _interopRequireWildcard(require("react"));

var _styledComponents = _interopRequireDefault(require("styled-components"));

var _utils = require("../../../utils");

var _Fieldset = require("../../Fieldset");

var _FieldCheckbox = require("../../Fields/FieldCheckbox");

var _height = require("../height");

var _templateObject;

var _excluded = ["autoFocus", "disabled", "inline", "name", "options", "defaultValue", "value", "onChange", "validationType"];

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function getCheckedProps(optionValue, value, defaultValue) {
  var key = value ? 'checked' : 'defaultChecked';
  var valueToUse = value || defaultValue || [];
  return (0, _defineProperty2["default"])({}, key, valueToUse.includes(optionValue));
}

var CheckboxGroupLayout = (0, _react.forwardRef)(function (_ref2, ref) {
  var autoFocus = _ref2.autoFocus,
      disabled = _ref2.disabled,
      inline = _ref2.inline,
      propsName = _ref2.name,
      options = _ref2.options,
      _ref2$defaultValue = _ref2.defaultValue,
      defaultValue = _ref2$defaultValue === void 0 ? [] : _ref2$defaultValue,
      value = _ref2.value,
      onChange = _ref2.onChange,
      validationType = _ref2.validationType,
      rest = (0, _objectWithoutProperties2["default"])(_ref2, _excluded);
  var name = (0, _utils.useID)(propsName);
  var uncontrolledValueRef = (0, _react.useRef)(defaultValue);
  var getChangeHandler = (0, _react.useCallback)(function (optionValue) {
    return onChange ? function () {
      var oldValue = value || uncontrolledValueRef.current;
      var newValue = (0, _xor["default"])(oldValue, [optionValue]);
      onChange(newValue);
      uncontrolledValueRef.current = newValue;
    } : undefined;
  }, [onChange, value]);
  var checkboxes = options.map(function (option, index) {
    var checkedProps = getCheckedProps(option.value, value, defaultValue);
    var autoFocusProps = index === 0 && autoFocus ? {
      autoFocus: autoFocus
    } : {};
    var handleChange = getChangeHandler(option.value);
    return _react["default"].createElement(_FieldCheckbox.FieldCheckbox, (0, _extends2["default"])({
      onChange: handleChange,
      disabled: option.disabled || disabled,
      key: option.value,
      label: option.label,
      detail: option.detail,
      name: name,
      validationType: validationType,
      value: option.value
    }, checkedProps, autoFocusProps));
  });
  return _react["default"].createElement(_Fieldset.Fieldset, (0, _extends2["default"])({
    "data-testid": "checkbox-list",
    inline: inline,
    wrap: inline,
    gap: !inline ? 'u1' : undefined,
    width: inline ? 'auto' : undefined,
    ref: ref
  }, rest), checkboxes);
});
CheckboxGroupLayout.displayName = 'CheckboxGroupLayout';
var CheckboxGroup = (0, _styledComponents["default"])(CheckboxGroupLayout).withConfig({
  displayName: "CheckboxGroup",
  componentId: "sc-kl6hc5-0"
})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  ", " {\n    ", "\n  }\n"])), _FieldCheckbox.FieldCheckbox, function (_ref3) {
  var inline = _ref3.inline;
  return inline ? "line-height: ".concat(_height.inputHeight, ";") : '';
});
exports.CheckboxGroup = CheckboxGroup;
//# sourceMappingURL=CheckboxGroup.js.map

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Magento\ProductAlert\Controller\Unsubscribe;

use Magento\ProductAlert\Controller\Unsubscribe as UnsubscribeController;
use Magento\Framework\App\Action\Context;
use Magento\Customer\Model\Session as CustomerSession;
use Magento\Catalog\Api\ProductRepositoryInterface;
use Magento\Framework\Controller\ResultFactory;
use Magento\Framework\Exception\NoSuchEntityException;

class Price extends UnsubscribeController
{
    /**
     * @var \Magento\Catalog\Api\ProductRepositoryInterface
     */
    protected $productRepository;

    /**
     * @param \Magento\Framework\App\Action\Context $context
     * @param \Magento\Customer\Model\Session $customerSession
     * @param \Magento\Catalog\Api\ProductRepositoryInterface $productRepository
     */
    public function __construct(
        Context $context,
        CustomerSession $customerSession,
        ProductRepositoryInterface $productRepository
    ) {
        $this->productRepository = $productRepository;
        parent::__construct($context, $customerSession);
    }

    /**
     * @return \Magento\Framework\Controller\Result\Redirect
     */
    public function execute()
    {
        $productId = (int)$this->getRequest()->getParam('product');
        /** @var \Magento\Framework\Controller\Result\Redirect $resultRedirect */
        $resultRedirect = $this->resultFactory->create(ResultFactory::TYPE_REDIRECT);
        if (!$productId) {
            $resultRedirect->setPath('/');
            return $resultRedirect;
        }

        try {
            /* @var $product \Magento\Catalog\Model\Product */
            $product = $this->productRepository->getById($productId);
            if (!$product->isVisibleInCatalog()) {
                throw new NoSuchEntityException();
            }
            /** @var \Magento\ProductAlert\Model\Price $model */
            $model = $this->_objectManager->create('Magento\ProductAlert\Model\Price')
                ->setCustomerId($this->customerSession->getCustomerId())
                ->setProductId($product->getId())
                ->setWebsiteId(
                    $this->_objectManager->get('Magento\Store\Model\StoreManagerInterface')
                        ->getStore()
                        ->getWebsiteId()
                )
                ->loadByParam();
            if ($model->getId()) {
                $model->delete();
            }

            $this->messageManager->addSuccess(__('You deleted the alert subscription.'));
        } catch (NoSuchEntityException $noEntityException) {
            $this->messageManager->addError(__('We can\'t find the product.'));
            $resultRedirect->setPath('customer/account/');
            return $resultRedirect;
        } catch (\Exception $e) {
            $this->messageManager->addException($e, __('We can\'t update the alert subscription right now.'));
        }
        $resultRedirect->setUrl($product->getProductUrl());
        return $resultRedirect;
    }
}


text:
import sys

import numpy as np
import pandas as pd
from pandas.api.types import is_list_like, is_scalar

from dask.dataframe import methods
from dask.dataframe.core import DataFrame, Series, apply_concat_apply, map_partitions
from dask.dataframe.utils import has_known_categories
from dask.utils import M

###############################################################
# Dummies
###############################################################

def get_dummies(
    data,
    prefix=None,
    prefix_sep="_",
    dummy_na=False,
    columns=None,
    sparse=False,
    drop_first=False,
    dtype=np.uint8,
    **kwargs,
):
    """
    Convert categorical variable into dummy/indicator variables.

    Data must have category dtype to infer result's ``columns``.

    Parameters
    ----------
    data : Series, or DataFrame
        For Series, the dtype must be categorical.
        For DataFrame, at least one column must be categorical.
    prefix : string, list of strings, or dict of strings, default None
        String to append DataFrame column names.
        Pass a list with length equal to the number of columns
        when calling get_dummies on a DataFrame. Alternatively, `prefix`
        can be a dictionary mapping column names to prefixes.
    prefix_sep : string, default '_'
        If appending prefix, separator/delimiter to use. Or pass a
        list or dictionary as with `prefix.`
    dummy_na : bool, default False
        Add a column to indicate NaNs, if False NaNs are ignored.
    columns : list-like, default None
        Column names in the DataFrame to be encoded.
        If `columns` is None then all the columns with
        `category` dtype will be converted.
    sparse : bool, default False
        Whether the dummy columns should be sparse or not.  Returns
        SparseDataFrame if `data` is a Series or if all columns are included.
        Otherwise returns a DataFrame with some SparseBlocks.

        .. versionadded:: 0.18.2

    drop_first : bool, default False
        Whether to get k-1 dummies out of k categorical levels by removing the
        first level.

    dtype : dtype, default np.uint8
        Data type for new columns. Only a single dtype is allowed.

        .. versionadded:: 0.18.2

    Returns
    -------
    dummies : DataFrame

    Examples
    --------
    Dask's version only works with Categorical data, as this is the only way to
    know the output shape without computing all the data.

    >>> import pandas as pd
    >>> import dask.dataframe as dd
    >>> s = dd.from_pandas(pd.Series(list('abca')), npartitions=2)
    >>> dd.get_dummies(s)
    Traceback (most recent call last):
        ...
    NotImplementedError: `get_dummies` with non-categorical dtypes is not supported...

    With categorical data:

    >>> s = dd.from_pandas(pd.Series(list('abca'), dtype='category'), npartitions=2)
    >>> dd.get_dummies(s)  # doctest: +NORMALIZE_WHITESPACE
    Dask DataFrame Structure:
                       a      b      c
    npartitions=2
    0              uint8  uint8  uint8
    2                ...    ...    ...
    3                ...    ...    ...
    Dask Name: get_dummies, 2 graph layers
    >>> dd.get_dummies(s).compute()  # doctest: +ELLIPSIS
       a  b  c
    0  1  0  0
    1  0  1  0
    2  0  0  1
    3  1  0  0

    See Also
    --------
    pandas.get_dummies
    """
    if isinstance(data, (pd.Series, pd.DataFrame)):
        return pd.get_dummies(
            data,
            prefix=prefix,
            prefix_sep=prefix_sep,
            dummy_na=dummy_na,
            columns=columns,
            sparse=sparse,
            drop_first=drop_first,
            dtype=dtype,
            **kwargs,
        )

    not_cat_msg = (
        "`get_dummies` with non-categorical dtypes is not "
        "supported. Please use `df.categorize()` beforehand to "
        "convert to categorical dtype."
    )

    unknown_cat_msg = (
        "`get_dummies` with unknown categories is not "
        "supported. Please use `column.cat.as_known()` or "
        "`df.categorize()` beforehand to ensure known "
        "categories"
    )

    if isinstance(data, Series):
        if not methods.is_categorical_dtype(data):
            raise NotImplementedError(not_cat_msg)
        if not has_known_categories(data):
            raise NotImplementedError(unknown_cat_msg)
    elif isinstance(data, DataFrame):
        if columns is None:
            if (data.dtypes == "object").any():
                raise NotImplementedError(not_cat_msg)
            columns = data._meta.select_dtypes(include=["category"]).columns
        else:
            if not all(methods.is_categorical_dtype(data[c]) for c in columns):
                raise NotImplementedError(not_cat_msg)

        if not all(has_known_categories(data[c]) for c in columns):
            raise NotImplementedError(unknown_cat_msg)

    package_name = data._meta.__class__.__module__.split(".")[0]
    dummies = sys.modules[package_name].get_dummies

    return map_partitions(
        dummies,
        data,
        prefix=prefix,
        prefix_sep=prefix_sep,
        dummy_na=dummy_na,
        columns=columns,
        sparse=sparse,
        drop_first=drop_first,
        dtype=dtype,
        **kwargs,
    )

###############################################################
# Pivot table
###############################################################

def pivot_table(df, index=None, columns=None, values=None, aggfunc="mean"):
    """
    Create a spreadsheet-style pivot table as a DataFrame. Target ``columns``
    must have category dtype to infer result's ``columns``.
    ``index``, ``columns``, and ``aggfunc`` must be all scalar.
    ``values`` can be scalar or list-like.

    Parameters
    ----------
    df : DataFrame
    index : scalar
        column to be index
    columns : scalar
        column to be columns
    values : scalar or list(scalar)
        column(s) to aggregate
    aggfunc : {'mean', 'sum', 'count', 'first', 'last'}, default 'mean'

    Returns
    -------
    table : DataFrame

    See Also
    --------
    pandas.DataFrame.pivot_table
    """

    if not is_scalar(index) or index is None:
        raise ValueError("'index' must be the name of an existing column")
    if not is_scalar(columns) or columns is None:
        raise ValueError("'columns' must be the name of an existing column")
    if not methods.is_categorical_dtype(df[columns]):
        raise ValueError("'columns' must be category dtype")
    if not has_known_categories(df[columns]):
        raise ValueError(
            "'columns' must have known categories. Please use "
            "`df[columns].cat.as_known()` beforehand to ensure "
            "known categories"
        )
    if not (
        is_list_like(values)
        and all([is_scalar(v) for v in values])
        or is_scalar(values)
    ):
        raise ValueError("'values' must refer to an existing column or columns")

    available_aggfuncs = ["mean", "sum", "count", "first", "last"]

    if not is_scalar(aggfunc) or aggfunc not in available_aggfuncs:
        raise ValueError(
            "aggfunc must be either " + ", ".join(f"'{x}'" for x in available_aggfuncs)
        )

    # _emulate can't work for empty data
    # the result must have CategoricalIndex columns

    columns_contents = pd.CategoricalIndex(df[columns].cat.categories, name=columns)
    if is_scalar(values):
        new_columns = columns_contents
    else:
        new_columns = pd.MultiIndex.from_product(
            (sorted(values), columns_contents), names=[None, columns]
        )

    if aggfunc in ["first", "last"]:
        # Infer datatype as non-numeric values are allowed
        if is_scalar(values):
            meta = pd.DataFrame(
                columns=new_columns,
                dtype=df[values].dtype,
                index=pd.Index(df._meta[index]),
            )
        else:
            meta = pd.DataFrame(
                columns=new_columns,
                index=pd.Index(df._meta[index]),
            )
            for value_col in values:
                meta[value_col] = meta[value_col].astype(df[values].dtypes[value_col])
    else:
        # Use float64 as other aggregate functions require numerical data
        meta = pd.DataFrame(
            columns=new_columns, dtype=np.float64, index=pd.Index(df._meta[index])
        )

    kwargs = {"index": index, "columns": columns, "values": values}

    if aggfunc in ["sum", "mean"]:
        pv_sum = apply_concat_apply(
            [df],
            chunk=methods.pivot_sum,
            aggregate=methods.pivot_agg,
            meta=meta,
            token="pivot_table_sum",
            chunk_kwargs=kwargs,
        )

    if aggfunc in ["count", "mean"]:
        pv_count = apply_concat_apply(
            [df],
            chunk=methods.pivot_count,
            aggregate=methods.pivot_agg,
            meta=meta,
            token="pivot_table_count",
            chunk_kwargs=kwargs,
        )

    if aggfunc == "sum":
        return pv_sum
    elif aggfunc == "count":
        return pv_count
    elif aggfunc == "mean":
        return pv_sum / pv_count
    elif aggfunc == "first":
        return apply_concat_apply(
            [df],
            chunk=methods.pivot_first,
            aggregate=methods.pivot_agg_first,
            meta=meta,
            token="pivot_table_first",
            chunk_kwargs=kwargs,
        )
    elif aggfunc == "last":
        return apply_concat_apply(
            [df],
            chunk=methods.pivot_last,
            aggregate=methods.pivot_agg_last,
            meta=meta,
            token="pivot_table_last",
            chunk_kwargs=kwargs,
        )
    else:
        raise ValueError

###############################################################
# Melt
###############################################################

def melt(
    frame,
    id_vars=None,
    value_vars=None,
    var_name=None,
    value_name="value",
    col_level=None,
):
    """
    Unpivots a DataFrame from wide format to long format, optionally leaving identifier variables set.

    This function is useful to massage a DataFrame into a format where one or more columns are identifier variables
    (``id_vars``), while all other columns, considered measured variables (``value_vars``), are "unpivoted" to the row
    axis, leaving just two non-identifier columns, 'variable' and 'value'.

    Parameters
    ----------
    frame : DataFrame
    id_vars : tuple, list, or ndarray, optional
        Column(s) to use as identifier variables.
    value_vars : tuple, list, or ndarray, optional
        Column(s) to unpivot. If not specified, uses all columns that
        are not set as `id_vars`.
    var_name : scalar
        Name to use for the 'variable' column. If None it uses
        ``frame.columns.name`` or 'variable'.
    value_name : scalar, default 'value'
        Name to use for the 'value' column.
    col_level : int or string, optional
        If columns are a MultiIndex then use this level to melt.

    Returns
    -------
    DataFrame
        Unpivoted DataFrame.

    See Also
    --------
    pandas.DataFrame.melt
    """

    from dask.dataframe.core import no_default

    return frame.map_partitions(
        M.melt,
        meta=no_default,
        id_vars=id_vars,
        value_vars=value_vars,
        var_name=var_name,
        value_name=value_name,
        col_level=col_level,
        token="melt",
    )


text:
% Wrapper for vl_nnlogScale2Scale block
% inputs{1} :   s     : 1 x 1 x 1 x b
% outputs{1}:   y     : 1 x 1 x 1 x b

classdef logScale2Scale < dagnn.Layer
    methods
        function outputs = forward(~, inputs, ~)

            useGPU = isa(inputs{1}, 'gpuArray');
            if useGPU
                outputs{1} = gpuArray( vl_nnlogScale2Scale(gather(inputs{1})) );
            else
                outputs{1} = vl_nnlogScale2Scale(inputs{1});
            end

        end

        function [derInputs, derParams] = backward(~, inputs, ~, derOutputs)

            useGPU = isa(inputs{1}, 'gpuArray');
            if useGPU
                derInputs{1} = gpuArray( vl_nnlogScale2Scale(gather(inputs{1}), gather(derOutputs{1})) );
            else
                derInputs{1} = vl_nnlogScale2Scale(inputs{1}, derOutputs{1});
            end

            derParams = {};
        end

        function outputSizes = getOutputSizes(~, inputSizes)
            outputSizes = inputSizes{1};
        end

        function obj = logScale2Scale(varargin)
            obj.load(varargin);
        end
    end
end


text:
package org.albianj.kernel.impl;

import ognl.Ognl;
import org.albianj.except.AlbianRuntimeException;
import org.albianj.kernel.AlbianKernel;
import org.albianj.kernel.AlbianState;
import org.albianj.kernel.IAlbianTransmitterService;
import org.albianj.kernel.KernelSetting;
import org.albianj.logger.AlbianLoggerLevel;
import org.albianj.logger.IAlbianLoggerService;
import org.albianj.logger.IAlbianLoggerService2;
import org.albianj.reflection.AlbianTypeConvert;
import org.albianj.runtime.AlbianModuleType;
import org.albianj.service.*;
import org.albianj.service.impl.FreeAlbianServiceParser;
import org.albianj.verify.Validate;

import java.util.*;

/**
 * @author Seapeak
 */
@AlbianKernel
public class AlbianTransmitterService implements IAlbianTransmitterService {
    private static AlbianState state = AlbianState.Normal;
    private static Date startDateTime;
    private static String serialId;

    public String getServiceName() {
        return Name;
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#getStartDateTime()
     */
    @Override
    public Date getStartDateTime() {
        return startDateTime;
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#getSerialId()
     */
    @Override
    public String getSerialId() {
        return serialId;
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#getLifeState()
     */
    @Override
    public AlbianState getLifeState() {
        return state;
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#start(java.lang.String)
     */
    @Override
    public void start(String configUrl) throws Exception {
        makeEnvironment();
        KernelSetting.setAlbianConfigFilePath(configUrl);
        start();
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#start(java.lang.String, java.lang.String)
     */
    @Override
    public void start(String kernelpath, String configPath)
            throws Exception {
        makeEnvironment();
        KernelSetting.setAlbianConfigFilePath(configPath);
        KernelSetting.setAlbianKernelConfigFilePath(kernelpath);
        start();
    }

    @Override
    public void start() throws Exception {
        makeEnvironment();
        startDateTime = new Date();
        doStart();
    }

    public void doStart() throws Exception {

        // do load builtin service
        AlbianBuiltinServiceLoader bltSevLoader = new AlbianBuiltinServiceLoader();
        bltSevLoader.loadServices();
        Map<String, IAlbianServiceAttribute> bltSrvAttrs = bltSevLoader.getBltSrvAttrs();

        //do load bussiness service
        Map<String, IAlbianServiceAttribute> bnsSrvAttrs = (Map<String, IAlbianServiceAttribute>)
                ServiceAttributeMap
                        .get(FreeAlbianServiceParser.ALBIANJSERVICEKEY);

        Map<String, IAlbianServiceAttribute> mapAttr = new HashMap<>();
        mapAttr.putAll(bnsSrvAttrs); // copy it for field setter

        for (String bltServKey : bltSrvAttrs.keySet()) { // remove builtin service in service.xml
            if (mapAttr.containsKey(bltServKey)) {
                mapAttr.remove(bltServKey);
            }
        }

        Map<String, IAlbianServiceAttribute> failMap = new LinkedHashMap<String, IAlbianServiceAttribute>();
        int lastFailSize = 0;
        int currentFailSize = 0;
        Exception e = null;
        while (true) {
            lastFailSize = currentFailSize;
            currentFailSize = 0;
            String sType = null;
            String id = null;
            String sInterface = null;
            for (Map.Entry<String, IAlbianServiceAttribute> entry : mapAttr
                    .entrySet())
                try {
                    IAlbianServiceAttribute serviceAttr = entry.getValue();
                    IAlbianService service = AlbianServiceLoader.makeupService(serviceAttr,mapAttr);
                    ServiceContainer.addService(serviceAttr.getId(), service);
                } catch (Exception exc) {
                    AlbianServiceRouter.getLogger2().logAndThrow(IAlbianLoggerService2.AlbianRunningLoggerName,
                            IAlbianLoggerService2.InnerThreadName,
                            AlbianLoggerLevel.Info, exc, AlbianModuleType.AlbianKernel,
                            "Kernel is error.", "load and init service:%s with class:%s is fail.",
                            id, sType);
                    e = exc;
                    currentFailSize++;
                    failMap.put(entry.getKey(), entry.getValue());
                }
            if (0 == currentFailSize) {
                // if open the distributed mode,
                // please contact to manager machine to logout the system.
                AlbianServiceRouter.getLogger2().log(IAlbianLoggerService.AlbianRunningLoggerName,
                        IAlbianLoggerService2.InnerThreadName,
                        AlbianLoggerLevel.Info,
                        "load service is success,then set field in the services!");

                break;// load service successen
            }

            if (lastFailSize == currentFailSize) {
                // startup the service fail in this times,
                // so throw the exception and stop the albianj engine
                state = AlbianState.Unloading;
                AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
                        IAlbianLoggerService2.InnerThreadName,
                        AlbianLoggerLevel.Error, "startup albianj engine is fail,maybe cross refernce.");
                if (null != e) {
                    AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
                            IAlbianLoggerService2.InnerThreadName,
                            AlbianLoggerLevel.Error, e, "startup the service:%s is fail.", failMap.keySet().toString());
                }
                ServiceContainer.clear();
                state = AlbianState.Unloaded;
                throw e;
            } else {
                mapAttr.clear();
                mapAttr.putAll(failMap);
                failMap.clear();
            }
        }

        // merger kernel service and bussines service
        // then update the all service attribute
        bltSrvAttrs.putAll(bnsSrvAttrs);
        ServiceAttributeMap.insert(FreeAlbianServiceParser.ALBIANJSERVICEKEY, bltSrvAttrs);
        //set field in service
//        if (!setServiceFields(bltSrvAttrs)) {
//            AlbianServiceRouter.getLogger2().log(IAlbianLoggerService.AlbianRunningLoggerName,
//                    IAlbianLoggerService2.InnerThreadName,
//                    AlbianLoggerLevel.Error,
//                    " set field in the services is fail!startup albianj is fail.");
//            throw new AlbianRuntimeException("startup albianj is fail.");
//
//        }
        state = AlbianState.Running;
        AlbianServiceRouter.getLogger2().log(IAlbianLoggerService.AlbianRunningLoggerName,
                IAlbianLoggerService2.InnerThreadName,
                AlbianLoggerLevel.Info,
                "set fields in the service over.Startup albianj is success!");

    }

//    private boolean setServiceFields(Map<String, IAlbianServiceAttribute> attrMap) {
//        // set fields last
//        // set fields at the end because for ref service across at some servics
//        int last_fail_times = 0;
//        int curr_fail_times = 0;
//        while (true) {
//            for (IAlbianServiceAttribute attr : attrMap.values()) {
//                if (Validate.isNullOrEmpty(attr.getServiceFields())) {
//                    continue;
//                }
//                IAlbianService service = ServiceContainer.getService(attr.getId());
//                if(Validate.isNullOrEmpty(attr.getServiceFields())) {
//                    continue;
//                }
//                for (IAlbianServiceFieldAttribute fAttr : attr.getServiceFields().values()) {
//                    if (fAttr.isReady()) {
//                        continue; // already set
//                    }
//                    if (!fAttr.getType().toLowerCase().equals("ref")) { // not set ref
//                        try {
//                            Object o = AlbianTypeConvert.toRealObject(
//                                    fAttr.getType(), fAttr.getValue());
//                            fAttr.getField().set(service, o);
//                            fAttr.setReady(true);
//                        } catch (Exception e) {
//                            AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                    IAlbianLoggerService2.InnerThreadName,
//                                    AlbianLoggerLevel.Warn, e,
//                                    "set field %s.%s = %s is fail.the field type is not ref.",
//                                    attr.getId(), fAttr.getName(), fAttr.getValue());
//                            ++curr_fail_times;
//                        }
//                        continue;
//                    }
//
//                    String value = fAttr.getValue();
//                    Object realObject = null;
//                    int indexof = value.indexOf(".");
//                    if (-1 == indexof) { // real ref service
//                        realObject = AlbianServiceRouter.getSingletonService(
//                                IAlbianService.class, value, false);
//                        if (!fAttr.getAllowNull() && null == realObject) {
//                            AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                    IAlbianLoggerService2.InnerThreadName,
//                                    AlbianLoggerLevel.Warn,
//                                    "not found ref service ->%s to set field -> %s in service -> %s. ",
//                                    value, fAttr.getName(), attr.getId());
//                            ++curr_fail_times;
//                            continue;
//                        }
//
//                        if (null != realObject) {
//                            try {
//                                fAttr.getField().set(service, realObject);
//                                fAttr.setReady(true);
//                            } catch (Exception e) {
//                                AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                        IAlbianLoggerService2.InnerThreadName,
//                                        AlbianLoggerLevel.Warn, e,
//                                        "set field %s.%s = %s is fail.the field type is ref.",
//                                        attr.getId(), fAttr.getName(), fAttr.getValue());
//                                ++curr_fail_times;
//                            }
//                        }
//                        continue;
//                    }
//
//                    String refServiceId = value.substring(0, indexof);
//                    String exp = value.substring(indexof + 1);
//                    IAlbianService refService = AlbianServiceRouter.getSingletonService(
//                            IAlbianService.class, refServiceId, false);
//
//                    if (!fAttr.getAllowNull() && null == refService) {
//                        AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                IAlbianLoggerService2.InnerThreadName,
//                                AlbianLoggerLevel.Warn,
//                                " %s.%s = %s.%s is fail. not found ref service -> %s exp -> %s. ",
//                                attr.getId(), fAttr.getName(), refServiceId, exp, refServiceId, exp);
//                        ++curr_fail_times;
//                        continue;
//                    }
//
//                    if (null != refService) {
//                        IAlbianServiceAttribute sAttr = attrMap.get(refServiceId);
//                        Object refRealObj = sAttr.getServiceClass().cast(refService);//must get service full type sign
//                        try {
//                            realObject = Ognl.getValue(exp, refRealObj);// get read value from full-sgin ref service
//                        } catch (Exception e) {
//                            AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                    IAlbianLoggerService2.InnerThreadName,
//                                    AlbianLoggerLevel.Warn, e,
//                                    " %s.%s = %s.%s is fail. not found exp -> %s in ref service -> %s. ",
//                                    attr.getId(), fAttr.getName(), refServiceId, exp, exp, refServiceId);
//                            ++curr_fail_times;
//                            continue;
//                        }
//                        if (null == realObject && !fAttr.getAllowNull()) {
//                            AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                    IAlbianLoggerService2.InnerThreadName,
//                                    AlbianLoggerLevel.Warn,
//                                    " %s.%s = %s.%s is fail. not found ref service -> %s exp -> %s. ",
//                                    attr.getId(), fAttr.getName(), refServiceId, exp, refServiceId, exp);
//                            ++curr_fail_times;
//                            continue;
//                        }
//                        if (null != realObject) {
//                            try {
//                                fAttr.getField().set(service, realObject);
//                                fAttr.setReady(true);
//                            } catch (Exception e) {
//                                AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
//                                        IAlbianLoggerService2.InnerThreadName,
//                                        AlbianLoggerLevel.Warn, e,
//                                        " %s.%s = %s.%s is fail. ",
//                                        attr.getId(), fAttr.getName(), refServiceId, exp);
//                                ++curr_fail_times;
//                                continue;
//                            }
//                        }
//                    }
//                }
//            }
//
//            if (0 == curr_fail_times) {
//                break;
//            }
//            if (curr_fail_times == last_fail_times) {//across ref in the service
//
//                return false;
//            }
//            last_fail_times = curr_fail_times;
//            curr_fail_times = 0;
//        }
//        return true;
//    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#requestHandlerContext()
     */
    @Override
    public String requestHandlerContext() {
        if (AlbianState.Running != state) {
            return "Albian is not ready,Please wait a minute or contact administrators!";
        }
        return "";
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#unload()
     */
    @Override
    public void unload() throws Exception {
        Set<String> keys = ServiceContainer.getAllServiceNames();
        for (String key : keys) {
            try {
                IAlbianService service = ServiceContainer.getService(key);
                service.beforeUnload();
                service.unload();
                service.afterUnload();
            } catch (Exception e) {
                AlbianServiceRouter.getLogger2().log(IAlbianLoggerService2.AlbianRunningLoggerName,
                        IAlbianLoggerService2.InnerThreadName,
                        AlbianLoggerLevel.Error, e, "unload the service is fail.");
            }
        }
    }

    /* (non-Javadoc)
     * @see org.albianj.kernel.impl.IAlbianBootService#makeEnvironment()
     */
    @Override
    public void makeEnvironment() {
        String system = System.getProperty("os.name");
        if (system.toLowerCase().contains("windows"))// start with '/'
        {
            KernelSetting.setSystem(KernelSetting.Windows);
        } else {
            KernelSetting.setSystem(KernelSetting.Linux);
        }
    }

}


text:
Engine::Engine(const cl::Program &subsampler,
               const cl::Program &projection,
               const cl::Program &integrator,
               const cl::ImageGL &image)
    : frame(image)
{
    core.push_back(scheduler::acquire("core/observer"));
    core.push_back(scheduler::acquire("core/geometry"));
    core.push_back(scheduler::acquire("core/frame_io"));
    core.push_back(scheduler::acquire("core/math_lib"));
    core.push_back(scheduler::acquire("core/prng_lib"));
    core.push_back(scheduler::acquire("main"));
    modules[Module::SUBSAMPLER] = subsampler;
    modules[Module::PROJECTION] = projection;
    modules[Module::INTEGRATOR] = integrator;

    attach(frame);
    link();
}

void Engine::set_module(Module type, const cl::Program &module)
{
    modules[type] = module;
    link(); // new programs
}

void Engine::resize_frame(const cl::ImageGL &image)
{
    frame.resize(image);
    frame.notify_cb(kernels);
}

void Engine::clear_frame(void)
{
    frame.clear();
}

void Engine::sample(void)
{
    frame.next();
    scheduler::run(kernels["render"], cl::NDRange(frame.width() * frame.height()));
}

void Engine::draw(void)
{
    scheduler::run(kernels["interop_copy"], cl::NDRange(frame.width() * frame.height()));
}

void Engine::attach(const std::function
                    <void(std::map<std::string, cl::Kernel>&)>
                    &callback)
{
    callbacks.push_back(callback);
    if (!kernels.empty()) callback(kernels);
}

void Engine::notify(void)
{
    for (auto &callback : callbacks) callback(kernels);
}

void Engine::link(void)
{
    std::vector<cl::Program> programs(core); // link all programs
    for(auto &it : modules) programs.push_back(it.second);
    program = scheduler::link(programs, "renderer");
    kernels = scheduler::get_all(program);
    clear_frame(); // this is necessary
    notify(); // notify all objects
}


text:
namespace ppapi {

class TrackedCallback;

namespace thunk {

class PPAPI_THUNK_EXPORT PPB_HostResolver_API {
 public:
  virtual ~PPB_HostResolver_API() {}

  virtual int32_t Resolve(const char* host,
                          uint16_t port,
                          const PP_HostResolver_Hint* hint,
                          scoped_refptr<TrackedCallback> callback) = 0;
  virtual PP_Var GetCanonicalName() = 0;
  virtual uint32_t GetNetAddressCount() = 0;
  virtual PP_Resource GetNetAddress(uint32_t index) = 0;
};

}  // namespace thunk
}  // namespace ppapi

#endif  // PPAPI_THUNK_PPB_TCP_SOCKET_API_H_


text:
/**
 *
This package contains the serverside client functionality

 */
package com.hazelcast.client;


text:
import setuptools

setuptools.setup(
    python_requires='<3.8',
    entry_points={
        "console_scripts": [
            "microscopeimagequality=microscopeimagequality.application:command"
        ]
    },
    install_requires=[
        "click",
        "matplotlib",
        "nose",
        "numpy<1.19.0,>=1.16.0",
        "Pillow",
        "scikit-image",
        "scipy",
        "six",
        "tensorflow==2.6.4",
        "imagecodecs",
    ],
    test_requires=["pytest"],
    name="microscopeimagequality",
    package_data={
        "microscopeimagequality": [
            "data/"
        ]
    },
    classifiers=[
    'License :: OSI Approved :: Apache Software License',
    'Intended Audience :: Science/Research',
    'Programming Language :: Python :: 2.7',
    'Topic :: Scientific/Engineering'],
    description="Microscope Image Quality Classification",
    url='https://github.com/google/microscopeimagequality',
    author='Samuel Yang',
    author_email='samuely@google.com',
    license='Apache 2.0',
    packages=setuptools.find_packages(
        exclude=[
            "tests"
        ]
    ),
    version="0.1.0dev5"
)


text:
<script src="/js/jquery.scrollToTop.min.js"></script>

<script type="text/javascript">
    $(function() {
    $("#toTop").scrollToTop(1000);
    });
</script>


text:
Vectorcoin integration/staging tree
================================

http://www.vectorcoin.org

Copyright (c) 2009-2014 Bitcoin Developers
Copyright (c) 2011-2014 Vectorcoin Developers

What is Vectorcoin?
----------------

Vectorcoin is a peer-to-peer payment system utilizing the scrypt proof-of-work alorithm.
 - 30 second block targets
 - subsidy halves every 100k blocks (~5 weeks)
 - ~33 million total coins
 - initial block reward 100 VCT
 - difficulty retargets daily

For more information, as well as an immediately useable, binary version of
the Vectorcoin client sofware, see http://www.vectorcoin.org.

License
-------

Vectorcoin is released under the terms of the MIT license. See `COPYING` for more
information or see http://opensource.org/licenses/MIT.

Development process
-------------------

Developers work in their own trees, then submit pull requests when they think
their feature or bug fix is ready.

If it is a simple/trivial/non-controversial change, then one of the Vectorcoin
development team members simply pulls it.

If it is a *more complicated or potentially controversial* change, then the patch
submitter will be asked to start a discussion with the devs and community.

The patch will be accepted if there is broad consensus that it is a good thing.
Developers should expect to rework and resubmit patches if the code doesn't
match the project's coding conventions (see `doc/coding.txt`) or are
controversial.

The `master` branch is regularly built and tested, but is not guaranteed to be
completely stable. [Tags](https://github.com/vectorcoin-project/vectorcoin/tags) are created
regularly to indicate new official, stable release versions of Vectorcoin.

Testing
-------

Testing and code review is the bottleneck for development; we get more pull
requests than we can review and test. Please be patient and help out, and
remember this is a security-critical project where any mistake might cost people
lots of money.

### Automated Testing

Developers are strongly encouraged to write unit tests for new code, and to
submit new unit tests for old code.

Unit tests for the core code are in `src/test/`. To compile and run them:

    cd src; make -f makefile.unix test

Unit tests for the GUI code are in `src/qt/test/`. To compile and run them:

    qmake BITCOIN_QT_TEST=1 -o Makefile.test bitcoin-qt.pro
    make -f Makefile.test
    ./vectorcoin-qt_test


text:
'use strict';

var isNumeric = require('fast-isnumeric');

/**
 * aggNums() returns the result of an aggregate function applied to an array of
 * values, where non-numerical values have been tossed out.
 *
 * @param {function} f - aggregation function (e.g., Math.min)
 * @param {Number} v - initial value (continuing from previous calls)
 *      if there's no continuing value, use null for selector-type
 *      functions (max,min), or 0 for summations
 * @param {Array} a - array to aggregate (may be nested, we will recurse,
 *                    but all elements must have the same dimension)
 * @param {Number} len - maximum length of a to aggregate
 * @return {Number} - result of f applied to a starting from v
 */
exports.aggNums = function(f, v, a, len) {
    var i,
        b;
    if(!len) len = a.length;
    if(!isNumeric(v)) v = false;
    if(Array.isArray(a[0])) {
        b = new Array(len);
        for(i = 0; i < len; i++) b[i] = exports.aggNums(f, v, a[i]);
        a = b;
    }

    for(i = 0; i < len; i++) {
        if(!isNumeric(v)) v = a[i];
        else if(isNumeric(a[i])) v = f(+v, +a[i]);
    }
    return v;
};

/**
 * mean & std dev functions using aggNums, so it handles non-numerics nicely
 * even need to use aggNums instead of .length, to toss out non-numerics
 */
exports.len = function(data) {
    return exports.aggNums(function(a) { return a + 1; }, 0, data);
};

exports.mean = function(data, len) {
    if(!len) len = exports.len(data);
    return exports.aggNums(function(a, b) { return a + b; }, 0, data) / len;
};

exports.variance = function(data, len, mean) {
    if(!len) len = exports.len(data);
    if(!isNumeric(mean)) mean = exports.mean(data, len);

    return exports.aggNums(function(a, b) {
        return a + Math.pow(b - mean, 2);
    }, 0, data) / len;
};

exports.stdev = function(data, len, mean) {
    return Math.sqrt(exports.variance(data, len, mean));
};

/**
 * interp() computes a percentile (quantile) for a given distribution.
 * We interpolate the distribution (to compute quantiles, we follow method #10 here:
 * http://www.amstat.org/publications/jse/v14n3/langford.html).
 * Typically the index or rank (n * arr.length) may be non-integer.
 * For reference: ends are clipped to the extreme values in the array;
 * For box plots: index you get is half a point too high (see
 * http://en.wikipedia.org/wiki/Percentile#Nearest_rank) but note that this definition
 * indexes from 1 rather than 0, so we subtract 1/2 (instead of add).
 *
 * @param {Array} arr - This array contains the values that make up the distribution.
 * @param {Number} n - Between 0 and 1, n = p/100 is such that we compute the p^th percentile.
 * For example, the 50th percentile (or median) corresponds to n = 0.5
 * @return {Number} - percentile
 */
exports.interp = function(arr, n) {
    if(!isNumeric(n)) throw 'n should be a finite number';
    n = n * arr.length - 0.5;
    if(n < 0) return arr[0];
    if(n > arr.length - 1) return arr[arr.length - 1];
    var frac = n % 1;
    return frac * arr[Math.ceil(n)] + (1 - frac) * arr[Math.floor(n)];
};


text:
package com.cnc.httpclient.request;

import org.apache.http.HttpEntity;

public abstract class Payload {
   protected HttpEntity httpEntity;
   protected boolean multiPart;

   public abstract HttpEntity getHttpEntity();

   public abstract boolean isText();

   public boolean isMultiPart() {
      return multiPart;
   }
}


text:
package com.smart.cloud.fire.view;

import android.app.Activity;
import android.app.AlertDialog;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.bumptech.glide.util.Util;
import com.jakewharton.rxbinding.view.RxView;
import com.smart.cloud.fire.activity.NFCDev.NFCRecordBean;
import com.smart.cloud.fire.global.InitBaiduNavi;
import com.smart.cloud.fire.mvp.fragment.MapFragment.Smoke;
import com.smart.cloud.fire.utils.T;
import com.smart.cloud.fire.utils.Utils;

import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;

import butterknife.Bind;
import butterknife.ButterKnife;
import butterknife.OnClick;
import fire.cloud.smart.com.smartcloudfire.R;
import rx.functions.Action1;

/**
 * Created by Administrator on 2016/9/22.
 */
public class ShowSmokeDialog {
    Activity context;
    @Bind(R.id.user_smoke_dialog_tv2)
    TextView userSmokeDialogTv2;
    @Bind(R.id.user_smoke_dialog_tv5)
    TextView userSmokeDialogTv5;//@@11.08
    @Bind(R.id.user_smoke_dialog_tv6)
    TextView userSmokeDialogTv6;//@@11.08
    @Bind(R.id.user_smoke_dialog_tv3)
    TextView userSmokeDialogTv3;
    @Bind(R.id.user_smoke_mark_principal)
    TextView userSmokeMarkPrincipal;
    @Bind(R.id.user_smoke_mark_phone_tv)
    TextView userSmokeMarkPhoneTv;
    @Bind(R.id.user_smoke_mark_principal2)
    TextView userSmokeMarkPrincipal2;
    @Bind(R.id.user_smoke_mark_phone_tv2)
    TextView userSmokeMarkPhoneTv2;
    @Bind(R.id.normal_lead_btn)
    Button normalLeadBtn;
    @Bind(R.id.user_smoke_dialog_tv4)
    TextView user_smoke_dialog_tv4;//@@8.7设备id
    @Bind(R.id.contact1_lin)
    LinearLayout contact1_lin;//@@8.18
    @Bind(R.id.contact2_lin)
    LinearLayout contact2_lin;//@@8.18
    private Smoke smoke;
    private AlertDialog dialog;
    private View mView;
    private NFCRecordBean nfcsmoke;

    public ShowSmokeDialog(Activity context, View mView, Smoke smoke) {
        this.context = context;
        this.smoke = smoke;
        this.mView = mView;
        ButterKnife.bind(this, mView);
        showSmokeDialog(mView);
    }

    //@@8.18
    public ShowSmokeDialog(Activity context, View mView, NFCRecordBean smoke) {
        this.context = context;
        this.nfcsmoke = smoke;
        this.mView = mView;
        ButterKnife.bind(this, mView);
        showNFCDialog(mView);
    }

    //@@8.18
    private void showNFCDialog(final View mView) {
        RxView.clicks(normalLeadBtn).throttleFirst(2, TimeUnit.SECONDS)
                .subscribe(new Action1<Void>() {
                    @Override
                    public void call(Void aVoid) {
                        Reference<Activity> reference = new WeakReference(context);
                        Smoke smoketemp=new Smoke();
                        smoketemp.setLongitude(nfcsmoke.getLongitude());
                        smoketemp.setLatitude(nfcsmoke.getLatitude());
                        new InitBaiduNavi(reference.get(), smoketemp);
                        if (dialog != null) {
                            dialog.dismiss();
                            dialog = null;
                            ButterKnife.unbind(mView);
                        }
                    }
                });
        contact1_lin.setVisibility(View.GONE);
        contact2_lin.setVisibility(View.GONE);
        userSmokeMarkPhoneTv.setVisibility(View.GONE);
        userSmokeMarkPhoneTv2.setVisibility(View.GONE);
        userSmokeMarkPrincipal2.setVisibility(View.GONE);
        userSmokeMarkPrincipal.setVisibility(View.GONE);
        userSmokeDialogTv5.setVisibility(View.GONE);//@@11.08
        userSmokeDialogTv6.setVisibility(View.GONE);//@@11.08
        userSmokeDialogTv2.setText(nfcsmoke.getDeviceName());
        userSmokeDialogTv3.setText(nfcsmoke.getAddress());
        user_smoke_dialog_tv4.setText("ID:"+nfcsmoke.getUid());//@@8.7
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        dialog = builder.create();
        if(!dialog.isShowing()){
            dialog.show();
        }
        dialog.setContentView(mView);
    }

    public void showSmokeDialog(final View view) {
        RxView.clicks(normalLeadBtn).throttleFirst(2, TimeUnit.SECONDS)
                .subscribe(new Action1<Void>() {
                    @Override
                    public void call(Void aVoid) {
                        Reference<Activity> reference = new WeakReference(context);
                        new InitBaiduNavi(reference.get(), smoke);
                        if (dialog != null) {
                            dialog.dismiss();
                            dialog = null;
                            ButterKnife.unbind(view);
                        }
                    }
                });
        userSmokeMarkPhoneTv.setText(smoke.getPrincipal1Phone());
        userSmokeMarkPhoneTv2.setText(smoke.getPrincipal2Phone());
        userSmokeMarkPrincipal2.setText(smoke.getPrincipal2());
        userSmokeMarkPrincipal.setText(smoke.getPrincipal1());
        userSmokeDialogTv2.setText(smoke.getName());
        userSmokeDialogTv3.setText(smoke.getAddress());
        user_smoke_dialog_tv4.setText("ID:"+smoke.getMac());//@@8.7
        userSmokeDialogTv5.setText("区域:"+smoke.getAreaName());//@@11.08
        userSmokeDialogTv6.setText("类型:"+ Utils.getDeviceTypeNeme(smoke.getDeviceType()));//@@11.08
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        dialog = builder.create();
        if(!dialog.isShowing()){
            dialog.show();
        }
        dialog.setContentView(view);
    }

    @OnClick({R.id.user_phone_lin_one, R.id.user_phone_lin_two})
    public void onClick(View view){
        String phoneNum = null;
        switch (view.getId()){
            case R.id.user_phone_lin_one:
                phoneNum = smoke.getPrincipal1Phone();
                break;
            case R.id.user_phone_lin_two:
                phoneNum = smoke.getPrincipal2Phone();
                break;
            default:
                break;
        }
        if(Utils.isPhoneNumber(phoneNum)){
            if(dialog!=null){
                dialog.dismiss();
                dialog=null;
                ButterKnife.unbind(mView);
            }
            NormalDialog mNormalDialog = new NormalDialog(context, "是否需要拨打电话:", phoneNum,
                    "是", "否");
            mNormalDialog.showNormalDialog();
        }else{
            T.showShort(context, "电话号码不合法");
        }
    }
}


text:
package uk.gov.register.functional;

import org.apache.commons.codec.digest.DigestUtils;
import org.json.JSONException;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import uk.gov.register.functional.app.RegisterRule;
import uk.gov.register.functional.app.RsfRegisterDefinition;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static uk.gov.register.functional.app.TestRegister.address;

public class ItemResourceFunctionalTest {
    @ClassRule
    public static RegisterRule register = new RegisterRule();
    private static String item1 = "{\"address\":\"6789\",\"street\":\"presley\"}";
    private static String item2 = "{\"address\":\"145678\",\"street\":\"ellis\"}";

    @Before
    public void publishTestMessages() throws Throwable {
        register.wipe();
        register.loadRsf(address, RsfRegisterDefinition.ADDRESS_FIELDS + RsfRegisterDefinition.ADDRESS_REGISTER);

        String rsf = "add-item\t{\"address\":\"6789\",\"street\":\"presley\"}\n" +
                "add-item\t{\"address\":\"145678\",\"street\":\"ellis\"}\n" +
                "append-entry\tuser\tregister1\t2018-07-26T15:43:12Z\tsha-256:bd239db51960376826b937a615f0f3397485f00611d35bb7e951e357bf73b934\n" +
                "append-entry\tuser\tregister1\t2018-07-26T15:43:12Z\tsha-256:8ac926428ee49fb83c02bdd2556e62e84cfd9e636cd35eb1306ac8cb661e4983\n";

        register.loadRsf(address, rsf);
    }

    @Test
    public void jsonRepresentationOfAnItem() throws JSONException {
        String sha256Hex = DigestUtils.sha256Hex(item1);

        Response response = register.getRequest(address, String.format("/item/sha-256:%s.json", sha256Hex));

        assertThat(response.getStatus(), equalTo(200));

        JSONAssert.assertEquals(item1, response.readEntity(String.class), false);
    }

    @Test
    public void return200ResponseForTextHtmlMediaTypeWhenItemExists() {
        String sha256Hex = DigestUtils.sha256Hex(item1);

        Response response = register.getRequest(address, String.format("/item/sha-256:%s", sha256Hex), MediaType.TEXT_HTML);

        assertThat(response.getStatus(), equalTo(200));
    }

    @Test
    public void return404ResponseWhenItemNotExist() throws JSONException {
        Response response = register.getRequest(address, "/item/sha-256:notExistHexValue");

        assertThat(response.getStatus(), equalTo(404));
    }

    @Test
    public void return404ResponseWhenItemHexIsNotInProperFormat() throws JSONException {
        Response response = register.getRequest(address, "/item/notExistHexValue");

        assertThat(response.getStatus(), equalTo(404));
    }
}


text:
#pragma once

#include <algorithm>
#include <cmath>

namespace angles
{

/*!
 * \brief Convert degrees to radians
 */
template <typename T> static inline T from_degrees(T degrees)
{
  return degrees * M_PI / 180.0;
}

/*!
 * \brief Convert radians to degrees
 */
template <typename T> static inline T to_degrees(T radians)
{
  return radians * 180.0 / M_PI;
}

/*!
 * \brief normalize_angle_positive
 *
 *        Normalizes the angle to be 0 to 2*M_PI
 *        It takes and returns radians.
 */
template <typename T> static inline T normalize_angle_positive(T angle)
{
  return fmod(fmod(angle, 2.0 * M_PI) + 2.0 * M_PI, 2.0 * M_PI);
}

/*!
 * \brief normalize
 *
 * Normalizes the angle to be -M_PI circle to +M_PI circle
 * It takes and returns radians.
 *
 */
template <typename T> static inline T normalize_angle(T angle)
{
  T a = normalize_angle_positive(angle);
  if(a > M_PI) a -= 2.0 * M_PI;
  return a;
}

/*!
 * \function
 * \brief shortest_angular_distance
 *
 * Given 2 angles, this returns the shortest angular
 * difference.  The inputs and ouputs are of course radians.
 *
 * The result
 * would always be -pi <= result <= pi.  Adding the result
 * to "from" will always get you an equivelent angle to "to".
 */
template <typename T> static inline T shortest_angular_distance(T from, T to)
{
  return normalize_angle(to - from);
}

/*!
 * \function
 *
 * \brief returns the angle in [-2*M_PI, 2*M_PI]  going the other way along the
 * unit circle.
 * \param angle The angle to which you want to turn in the range [-2*M_PI,
 * 2*M_PI]
 * E.g. two_pi_complement(-M_PI/4) returns 7_M_PI/4
 * two_pi_complement(M_PI/4) returns -7*M_PI/4
 *
 */
template <typename T> static inline T two_pi_complement(T angle)
{
  // check input conditions
  if(angle > 2 * M_PI || angle < -2.0 * M_PI) angle = fmod(angle, 2.0 * M_PI);
  if(angle < 0)
    return (2 * M_PI + angle);
  else if(angle > 0)
    return (-2 * M_PI + angle);

  return (2 * M_PI);
}

/*!
 * \function
 *
 * \brief This function is only intended for internal use and not intended for
 * external use. If you do use it, read the documentation very carefully.
 * Returns the min and max amount (in radians) that can be moved from "from"
 * angle to "left_limit" and "right_limit".
 * \return returns false if "from" angle does not lie in the interval
 * [left_limit,right_limit]
 * \param from - "from" angle - must lie in [-M_PI, M_PI)
 * \param left_limit - left limit of valid interval for angular position - must
 * lie in [-M_PI, M_PI], left and right limits are specified on the unit circle
 * w.r.t to a reference pointing inwards
 * \param right_limit - right limit of valid interval for angular position -
 * must lie in [-M_PI, M_PI], left and right limits are specified on the unit
 * circle w.r.t to a reference pointing inwards
 * \param result_min_delta - minimum (delta) angle (in radians) that can be
 * moved from "from" position before hitting the joint stop
 * \param result_max_delta - maximum (delta) angle (in radians) that can be
 * movedd from "from" position before hitting the joint stop
 */
template <typename T>
static bool find_min_max_delta(T from, T left_limit, T right_limit,
                               T& result_min_delta, T& result_max_delta)
{
  T delta[4];

  delta[0] = shortest_angular_distance(from, left_limit);
  delta[1] = shortest_angular_distance(from, right_limit);

  delta[2] = two_pi_complement(delta[0]);
  delta[3] = two_pi_complement(delta[1]);

  if(delta[0] == 0)
  {
    result_min_delta = delta[0];
    result_max_delta = std::max<T>(delta[1], delta[3]);
    return true;
  }

  if(delta[1] == 0)
  {
    result_max_delta = delta[1];
    result_min_delta = std::min<T>(delta[0], delta[2]);
    return true;
  }

  T delta_min = delta[0];
  T delta_min_2pi = delta[2];
  if(delta[2] < delta_min)
  {
    delta_min = delta[2];
    delta_min_2pi = delta[0];
  }

  T delta_max = delta[1];
  T delta_max_2pi = delta[3];
  if(delta[3] > delta_max)
  {
    delta_max = delta[3];
    delta_max_2pi = delta[1];
  }

  //    printf("%f %f %f %f\n",delta_min,delta_min_2pi,delta_max,delta_max_2pi);
  if((delta_min <= delta_max_2pi) || (delta_max >= delta_min_2pi))
  {
    result_min_delta = delta_max_2pi;
    result_max_delta = delta_min_2pi;
    if(left_limit == -M_PI && right_limit == M_PI)
      return true;
    else
      return false;
  }
  result_min_delta = delta_min;
  result_max_delta = delta_max;
  return true;
}

/*!
 * \function
 *
 * \brief Returns the delta from "from_angle" to "to_angle" making sure it does
 * not violate limits specified by left_limit and right_limit.
 * The valid interval of angular positions is [left_limit,right_limit]. E.g.,
 * [-0.25,0.25] is a 0.5 radians wide interval that contains 0.
 * But [0.25,-0.25] is a 2*M_PI-0.5 wide interval that contains M_PI (but not
 * 0).
 * The value of shortest_angle is the angular difference between "from" and "to"
 * that lies within the defined valid interval.
 * E.g. shortest_angular_distance_with_limits(-0.5,0.5,0.25,-0.25,ss) evaluates
 * ss to 2*M_PI-1.0 and returns true while
 * shortest_angular_distance_with_limits(-0.5,0.5,-0.25,0.25,ss) returns false
 * since -0.5 and 0.5 do not lie in the interval [-0.25,0.25]
 *
 * \return true if "from" and "to" positions are within the limit interval,
 * false otherwise
 * \param from - "from" angle
 * \param to - "to" angle
 * \param left_limit - left limit of valid interval for angular position, left
 * and right limits are specified on the unit circle w.r.t to a reference
 * pointing inwards
 * \param right_limit - right limit of valid interval for angular position, left
 * and right limits are specified on the unit circle w.r.t to a reference
 * pointing inwards
 * \param shortest_angle - result of the shortest angle calculation
 */
template <typename T>
static inline bool
shortest_angular_distance_with_limits(T from, T to, T left_limit, T right_limit,
                                      T& shortest_angle)
{

  T min_delta = -2 * M_PI;
  T max_delta = 2 * M_PI;
  T min_delta_to = -2 * M_PI;
  T max_delta_to = 2 * M_PI;
  bool flag =
    find_min_max_delta(from, left_limit, right_limit, min_delta, max_delta);
  T delta = shortest_angular_distance(from, to);
  T delta_mod_2pi = two_pi_complement(delta);

  if(flag) // from position is within the limits
  {
    if(delta >= min_delta && delta <= max_delta)
    {
      shortest_angle = delta;
      return true;
    }
    else if(delta_mod_2pi >= min_delta && delta_mod_2pi <= max_delta)
    {
      shortest_angle = delta_mod_2pi;
      return true;
    }
    else // to position is outside the limits
    {
      find_min_max_delta(
        to, left_limit, right_limit, min_delta_to, max_delta_to);
      if(fabs(min_delta_to) < fabs(max_delta_to))
        shortest_angle = std::max<T>(delta, delta_mod_2pi);
      else if(fabs(min_delta_to) > fabs(max_delta_to))
        shortest_angle = std::min<T>(delta, delta_mod_2pi);
      else
      {
        if(fabs(delta) < fabs(delta_mod_2pi))
          shortest_angle = delta;
        else
          shortest_angle = delta_mod_2pi;
      }
      return false;
    }
  }
  else // from position is outside the limits
  {
    find_min_max_delta(to, left_limit, right_limit, min_delta_to, max_delta_to);

    if(fabs(min_delta) < fabs(max_delta))
      shortest_angle = std::min<T>(delta, delta_mod_2pi);
    else if(fabs(min_delta) > fabs(max_delta))
      shortest_angle = std::max<T>(delta, delta_mod_2pi);
    else
    {
      if(fabs(delta) < fabs(delta_mod_2pi))
        shortest_angle = delta;
      else
        shortest_angle = delta_mod_2pi;
    }
    return false;
  }

  shortest_angle = delta;
  return false;
}
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.heaton</groupId>
    <artifactId>java-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <me.version>1.0</me.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.other.wrong</groupId>
            <artifactId>logback-classic-1.0.13</artifactId>
            <version>${me.version}</version>
        </dependency>
        <dependency>
            <groupId>com.other.wrong</groupId>
            <artifactId>selenium-java-2.48.2</artifactId>
            <version>${me.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>


text:
<?php

namespace Elastica\Aggregation;

/**
 * Class Missing
 * @package Elastica\Aggregation
 * @link http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-aggregations-bucket-missing-aggregation.html
 */
class Missing extends AbstractAggregation
{
    /**
     * @param string $name  the name of this aggregation
     * @param string $field the field on which to perform this aggregation
     */
    public function __construct($name, $field)
    {
        parent::__construct($name);
        $this->setField($field);
    }

    /**
     * Set the field for this aggregation
     * @param  string  $field the name of the document field on which to perform this aggregation
     * @return Missing
     */
    public function setField($field)
    {
        return $this->setParam('field', $field);
    }
}


text:
const chalk = require('chalk');
const config = require("../config.json");
module.exports = client => {
  console.log(chalk.bold("Reconnecting @ " + Date()));
}


text:
function createVideoControls(){
	var vids = document.getElementsByTagName('video');
	for(var i=0; i<vids.length;i++){
		addControls(vids[i]);
	}
}

function addControls(vid){
	vid.removeAttribute('control');
	vid.height = vid.videoHeight;
	vid.width = vid.videoWidth;
	vid.parentNode.style.height = vid.videoHeight + 'px';
	vid.parentNode.style.width = videoWidth + 'px';

	var controls = document.createElement('div');
	control.setAttribute('class','controls');

	var play = document.createElement('button');
	play.setAttribute('title','Play');
	play.innerHTML = '&#x25BA';

	controls.appendChild(play);

	vid.parentNode.insertBefore(controls,vid);

	play.onclick() = function(){
		if(vid.ended){
			vid.currentTime = 0;
		}
		if(vid.paused){
			vid.play();
		}else{
			vid.pause();
		}
	};

	vid.addEventListener('play',function(){
		play.innerHTML = '▐▐';
		play.setAttribute('paused',true);
	},false);

	vid.addEventListener('pause',function(){
		play.removeAttribute('pause');
		play.innerHTML = '&#x25BA';
	},false);

	vid.addEventListener('ended',function(){
		vid.pause();
	},false);
}


text:
package vgrechka.phizdetsidea.phizdets.codeInsight.functionTypeComments;

import com.intellij.lang.DependentLanguage;
import com.intellij.lang.Language;
import vgrechka.phizdetsidea.phizdets.PhizdetsLanguage;

/**
 * @author Mikhail Golubev
 */
public class PyFunctionTypeAnnotationDialect extends Language implements DependentLanguage {
  public static final PyFunctionTypeAnnotationDialect INSTANCE = new PyFunctionTypeAnnotationDialect();

  protected PyFunctionTypeAnnotationDialect() {
    super(PhizdetsLanguage.getInstance(), "PyFunctionTypeComment");
  }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<title>Editor API</title>
<meta http-equiv="Content-Type" Content="text/html; charset=Windows-1251">
<link rel="stylesheet" type="text/css" href="../../styles/styles.css">

Editor API

main

Exported functions

Function	Description

ProcessEditorInput
process keyboard events

ProcessEditorEvent
process editor events

Service functions

Function	Description

Editor
allows to invoke the FAR internal editor.

EditorControl
provides access to low level internal editor API.

Structures

Structure	Description

EditorBookMarks
information about bookmarks in the currently edited file

EditorColor
information about color regions

EditorConvertPos
conversion between real and screen positions of the cursor

EditorConvertText
text conversion between OEM and internal FAR character set

EditorGetString
editor line retrieval

EditorInfo
current editor state

EditorSaveFile
editor file saving

EditorSelect
text selection/deselection in the editor

EditorSetParameter
editor parameters setting

EditorSetPosition
position setting in the editor

EditorSetString
change or insert string in the editor

See also:


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
C. r. Congr. natn. Socs. sav. Paris, sect. sci. , fasc. 1. (Paleobotanique) 105: 186 + pl. I, fig. 27 (1980)

#### Original name
Striadiporites boletelloides Sal.-Cheb. & Locq.

### Remarks
null


text:
const path = require('path')
module.exports = {
  base:'/eunomia.cbd.int/',
  title: 'Eunomia',
  description: 'Room reservation and manegment system.',
  themeConfig: {
    repo: 'scbd/eunomia.cbd.int',
    editLinks: true,
    docsDir: 'docs',
    docsBranch: 'master',
    lastUpdated: 'Last Updated', // string | boolean
    nav: [
      { text: 'Schedule',         link: '/schedule/' },
      { text: 'Reservations',     link: '/reservations/' },
      { text: 'Side-events',      link: '/side-events/' },
      { text: 'CCTV',             link: '/cctv/' },
      { text: 'Administration',   link: '/administration/' }
    ],
    locales: {
      '/': {
        label:        'English',
        selectText:   'Languages',
        editLinkText: 'Edit this page on GitHub',
        lastUpdated:  'Last Updated',
        title:        'Eunomia Documentation',
        description:  'Eunomia Documentation'
      }
    }
  }
}


text:
<?php
/**
 * Nofuzz\Helpers\Cipher
 *
 *   Wraps the OpenSSL encrypt() and decrypt() methods into easily usable static helper methods
 *   Note: Uses the Configuration setting "application.secret" as the default password.
 *
 * Example:
 *   $encryptedValue = \Nofuzz\Helpers\Cipher::encrypt( $plain );
 *   $plain = \Nofuzz\Helpers\Cipher::decrypt( $encryptedValue );
 *
 * @package  Nofuzz
 */
#################################################################################################################################

namespace Nofuzz\Helpers;

class Cipher implements \Nofuzz\Helpers\CipherInterface
{
  /**
   * Encrypt $data with $secret
   *
   * @param  string $data        [description]
   * @param  string $iv          [description]
   * @param  string $secret      [description]
   * @param  string $algorithm   [description]
   * @return string              Base64 Encoded String
   */
  public static function encrypt(string $data, string $secret='', string $algorithm='AES-256-CBC')
  {
    # If AES we will add a random 16 byte IV before the encrypted data
    if ( strtoupper(substr($algorithm,0,3))==='AES' ) {
      $iv = openssl_random_pseudo_bytes(16);
    } else {
      $iv = '';
    }

    # If no secret provided, use the one in config
    if (empty($secret))
      $secret = config()->get('application.secret');

    # Encrypt
    $result = openssl_encrypt($data,$algorithm,$secret,0,$iv);

    return base64_encode($iv.$result);
  }

  /**
   * Decrypt $data with $secret
   *
   * @param  string $data      [description]
   * @param  string $iv        [description]
   * @param  string $secret    [description]
   * @param  string $algorithm [description]
   * @return [type]            [description]
   */
  public static function decrypt(string $data, string $secret='', string $algorithm='AES-256-CBC')
  {
    # if AES we extract the 16 bytes in the beginning as the IV
    if ( strtoupper(substr($algorithm,0,3))==='AES' ) {
      $encoded  = base64_decode($data);
      $iv       = substr($encoded,0,16);
      $encoded  = substr($encoded,16);
    } else {
      $encoded = $data;
      $iv = '';
    }

    # If no secret provided, use the one in config
    if (empty($secret))
      $secret = config()->get('application.secret');

    # Decrypt
    $result = openssl_decrypt($encoded,$algorithm,$secret,0,$iv);

    return $result;
  }

  /**
   * Return array of Cipher methods available
   *
   * @return array
   */
  public static function getMethods(): array
  {
    return openssl_get_cipher_methods();
  }

}


text:
package org.geepawhill.wildapricot;

import org.geepawhill.server.LiveServer;
import org.geepawhill.wildapricot.data.ApiAccount;
import org.geepawhill.wildapricot.data.ApiAuthenticationToken;
import org.geepawhill.wildapricot.data.ApiContact;
import org.geepawhill.wildapricot.data.ApiContacts;

public class Main
{

	static final String APIKEY = "EDIT THIS TO HOLD YOUR APIKEY";

	public static void main(String[] args) throws Exception
	{

		WildApricotClient client = new WildApricotClient();
		LiveServer server = new LiveServer();
		ApiAuthenticationToken token = client.authenticate(server,APIKEY);
		ApiAccount[] accounts = client.fetchAccounts(server,token.access_token);
		ApiContacts contacts = client.fetchAllContacts(server,token.access_token,accounts[0].Id);
		for(ApiContact contact : contacts.Contacts)
		{
			System.out.println(contact.LastName+", "+contact.FirstName);
		}
	}
}


text:
.. _biology_examples:

Biology
=======

.. toctree::

   step_system