text:
class Cash < Account

  # Store accessors
  EXTRA_COLUMNS = [:email, :address, :phone].freeze
  store_accessor(:extras, *EXTRA_COLUMNS)

  # Validations
  validates :name, length: { minimum: 3 }

  # Related methods for money accounts
  include Models::Money

  def to_s
    name
  end
end


text:
#region License

#endregion
#if !CLR4
using System.Globalization;
using System.Collections;
using System.Security.Principal;
using System.Web.Caching;
namespace System.Web
{
    /// <summary>
    /// HttpContextBase
    /// </summary>
    //[TypeForwardedFrom("System.Web.Abstractions, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")]
    public abstract class HttpContextBase : IServiceProvider
    {
        //[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        protected HttpContextBase() { }

        public virtual void AddError(Exception errorInfo) { throw new NotImplementedException(); }
        public virtual void ClearError() { throw new NotImplementedException(); }
        public virtual object GetGlobalResourceObject(string classKey, string resourceKey) { throw new NotImplementedException(); }
        public virtual object GetGlobalResourceObject(string classKey, string resourceKey, CultureInfo culture) { throw new NotImplementedException(); }
        public virtual object GetLocalResourceObject(string virtualPath, string resourceKey) { throw new NotImplementedException(); }
        public virtual object GetLocalResourceObject(string virtualPath, string resourceKey, CultureInfo culture) { throw new NotImplementedException(); }
        public virtual object GetSection(string sectionName) { throw new NotImplementedException(); }
        public virtual object GetService(Type serviceType) { throw new NotImplementedException(); }
        public virtual void RemapHandler(IHttpHandler handler) { throw new NotImplementedException(); }
        public virtual void RewritePath(string path) { throw new NotImplementedException(); }
        public virtual void RewritePath(string path, bool rebaseClientPath) { throw new NotImplementedException(); }
        public virtual void RewritePath(string filePath, string pathInfo, string queryString) { throw new NotImplementedException(); }
        public virtual void RewritePath(string filePath, string pathInfo, string queryString, bool setClientFilePath) { throw new NotImplementedException(); }

        public virtual void SetSessionStateBehavior(SessionStateBehavior sessionStateBehavior) { throw new NotImplementedException(); }

        public virtual Exception[] AllErrors
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpApplicationStateBase Application
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpApplication ApplicationInstance
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        public virtual Cache Cache
        {
            get { throw new NotImplementedException(); }
        }

        public virtual IHttpHandler CurrentHandler
        {
            get { throw new NotImplementedException(); }
        }

        public virtual RequestNotification CurrentNotification
        {
            get { throw new NotImplementedException(); }
        }

        public virtual Exception Error
        {
            get { throw new NotImplementedException(); }
        }

        public virtual IHttpHandler Handler
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        public virtual bool IsCustomErrorEnabled
        {
            get { throw new NotImplementedException(); }
        }

        public virtual bool IsDebuggingEnabled
        {
            get { throw new NotImplementedException(); }
        }

        public virtual bool IsPostNotification
        {
            get { throw new NotImplementedException(); }
        }

        public virtual IDictionary Items
        {
            get { throw new NotImplementedException(); }
        }

        public virtual IHttpHandler PreviousHandler
        {
            get { throw new NotImplementedException(); }
        }

        public virtual ProfileBase Profile
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpRequestBase Request
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpResponseBase Response
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpServerUtilityBase Server
        {
            get { throw new NotImplementedException(); }
        }

        public virtual HttpSessionStateBase Session
        {
            get { throw new NotImplementedException(); }
        }

        public virtual bool SkipAuthorization
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        public virtual DateTime Timestamp
        {
            get { throw new NotImplementedException(); }
        }

        public virtual TraceContext Trace
        {
            get { throw new NotImplementedException(); }
        }

        public virtual IPrincipal User
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }
    }
}
#endif

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace Application\Migrations;

use Doctrine\DBAL\Migrations\AbstractMigration,
    Doctrine\DBAL\Schema\Schema;

class Version20121028150500 extends AbstractMigration
{
    public function up(Schema $schema)
    {
        $schema->getTable('education_course_types')->addColumn('age', 'string', array('length' => 8, 'notnull' => false));
    }

    public function down(Schema $schema)
    {
        $schema->getTable('education_course_types')->dropColumn('age');
    }
}


text:
- explain my current logic
- show examples
 - for example https://twitter.com/DinisCruz/status/743063496754094080


text:
"""
collection of evaluators for performing experiments, optimization, and robust
optimization

"""
import enum
import multiprocessing
import numbers
import os
import random
import shutil
import string
import sys
import threading
import warnings

from ema_workbench.em_framework.samplers import AbstractSampler
from .callbacks import DefaultCallback
from .points import experiment_generator, Scenario, Policy
from .ema_multiprocessing import LogQueueReader, initializer, add_tasks
from .experiment_runner import ExperimentRunner
from .model import AbstractModel
from .optimization import (
    evaluate_robust,
    evaluate,
    EpsNSGAII,
    to_problem,
    to_robust_problem,
    process_levers,
    process_uncertainties,
    process_robust,
    _optimize,
)
from .outcomes import ScalarOutcome, AbstractOutcome
from .salib_samplers import SobolSampler, MorrisSampler, FASTSampler
from .samplers import (
    MonteCarloSampler,
    FullFactorialSampler,
    LHSSampler,
    UniformLHSSampler,
    sample_levers,
    sample_uncertainties,
)
from .util import NamedObjectMap, determine_objects
from ..util import EMAError, get_module_logger, ema_logging

warnings.simplefilter("once", ImportWarning)

try:
    from .ema_ipyparallel import (
        start_logwatcher,
        set_engine_logger,
        initialize_engines,
        cleanup,
        _run_experiment,
    )
except (ImportError, ModuleNotFoundError):
    warnings.warn("ipyparallel not installed - IpyparalleEvaluator not available")

# Created on 5 Mar 2017
#
# .. codeauthor::jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>

__all__ = [
    "MultiprocessingEvaluator",
    "IpyparallelEvaluator",
    "optimize",
    "perform_experiments",
    "SequentialEvaluator",
    "Samplers",
]

_logger = get_module_logger(__name__)

class Samplers(enum.Enum):
    """
    Enum for different kinds of samplers
    """

    ## TODO:: have samplers register themselves on class instantiation
    ## TODO:: should not be defined here

    MC = MonteCarloSampler()
    LHS = LHSSampler()
    UNIFORM_LHS = UniformLHSSampler()
    FF = FullFactorialSampler()
    SOBOL = SobolSampler()
    FAST = FASTSampler()
    MORRIS = MorrisSampler()

class BaseEvaluator:
    """evaluator for experiments using a multiprocessing pool

    Parameters
    ----------
    msis : collection of models
    searchover : {None, 'levers', 'uncertainties'}, optional
                  to be used in combination with platypus

    Raises
    ------
    ValueError

    """

    reporting_frequency = 3

    def __init__(self, msis):
        super().__init__()

        if isinstance(msis, AbstractModel):
            msis = [msis]
        else:
            for entry in msis:
                if not isinstance(entry, AbstractModel):
                    raise TypeError(
                        f"{entry} should be an AbstractModel "
                        f"instance but is a {entry.__class__} instance"
                    )

        self._msis = msis
        self.callback = None

    def __enter__(self):
        self.initialize()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.finalize()

        if exc_type is not None:
            return False

    def initialize(self):
        """initialize the evaluator"""
        raise NotImplementedError

    def finalize(self):
        """finalize the evaluator"""
        raise NotImplementedError

    def evaluate_experiments(self, scenarios, policies, callback, combine="factorial"):
        """used by ema_workbench"""
        raise NotImplementedError

    def evaluate_all(self, jobs, **kwargs):
        """makes ema_workbench evaluators compatible with Platypus
        evaluators as used by platypus algorithms
        """
        self.callback()

        try:
            problem = jobs[0].solution.problem
        except IndexError:
            # no jobs to evaluate
            return jobs

        searchover = problem.searchover

        if searchover == "levers":
            scenarios, policies = process_levers(jobs)
            jobs_collection = zip(policies, jobs)
        elif searchover == "uncertainties":
            scenarios, policies = process_uncertainties(jobs)
            jobs_collection = zip(scenarios, jobs)
        elif searchover == "robust":
            scenarios, policies = process_robust(jobs)
            jobs_collection = zip(policies, jobs)
        else:
            raise NotImplementedError()

        # overwrite the default 10 progress reports  with 5 reports
        callback = perform_experiments(
            self._msis,
            evaluator=self,
            reporting_frequency=self.reporting_frequency,
            scenarios=scenarios,
            policies=policies,
            return_callback=True,
            log_progress=True,
        )

        experiments, outcomes = callback.get_results()

        if searchover in ("levers", "uncertainties"):
            evaluate(jobs_collection, experiments, outcomes, problem)
        else:
            evaluate_robust(jobs_collection, experiments, outcomes, problem)

        return jobs

    def perform_experiments(
        self,
        scenarios=0,
        policies=0,
        reporting_interval=None,
        reporting_frequency=10,
        uncertainty_union=False,
        lever_union=False,
        outcome_union=False,
        uncertainty_sampling=Samplers.LHS,
        lever_sampling=Samplers.LHS,
        callback=None,
        combine="factorial",
    ):
        """convenience method for performing experiments.

        is forwarded to :func:perform_experiments, with evaluator and
        models arguments added in.

        """
        return perform_experiments(
            self._msis,
            scenarios=scenarios,
            policies=policies,
            evaluator=self,
            reporting_interval=reporting_interval,
            reporting_frequency=reporting_frequency,
            uncertainty_union=uncertainty_union,
            lever_union=lever_union,
            outcome_union=outcome_union,
            uncertainty_sampling=uncertainty_sampling,
            lever_sampling=lever_sampling,
            callback=callback,
            combine=combine,
        )

    def optimize(
        self,
        algorithm=EpsNSGAII,
        nfe=10000,
        searchover="levers",
        reference=None,
        constraints=None,
        convergence_freq=1000,
        logging_freq=5,
        variator=None,
        **kwargs,
    ):
        """convenience method for outcome optimization.

        is forwarded to :func:optimize, with evaluator and models
        arguments added in.

        """
        return optimize(
            self._msis,
            algorithm=algorithm,
            nfe=int(nfe),
            searchover=searchover,
            evaluator=self,
            reference=reference,
            constraints=constraints,
            convergence_freq=convergence_freq,
            logging_freq=logging_freq,
            variator=variator,
            **kwargs,
        )

    def robust_optimize(
        self,
        robustness_functions,
        scenarios,
        algorithm=EpsNSGAII,
        nfe=10000,
        convergence_freq=1000,
        logging_freq=5,
        **kwargs,
    ):
        """convenience method for robust optimization.

        is forwarded to :func:robust_optimize, with evaluator and models
        arguments added in.

        """
        return robust_optimize(
            self._msis,
            robustness_functions,
            scenarios,
            self,
            algorithm=algorithm,
            nfe=nfe,
            convergence_freq=convergence_freq,
            logging_freq=logging_freq,
            **kwargs,
        )

class SequentialEvaluator(BaseEvaluator):
    def initialize(self):
        pass

    def finalize(self):
        pass

    def evaluate_experiments(self, scenarios, policies, callback, combine="factorial"):
        _logger.info("performing experiments sequentially")

        ex_gen = experiment_generator(scenarios, self._msis, policies, combine=combine)

        models = NamedObjectMap(AbstractModel)
        models.extend(self._msis)

        # TODO:: replace with context manager
        cwd = os.getcwd()
        runner = ExperimentRunner(models)

        for experiment in ex_gen:
            outcomes = runner.run_experiment(experiment)
            callback(experiment, outcomes)
        runner.cleanup()
        os.chdir(cwd)

class MultiprocessingEvaluator(BaseEvaluator):
    """evaluator for experiments using a multiprocessing pool

    Parameters
    ----------
    msis : collection of models
    n_processes : int (optional)
                  A negative number can be inputted to use the number of logical cores minus the negative cores.
                  For example, on a 12 thread processor, -2 results in using 10 threads.
    max_tasks : int (optional)

    note that the maximum number of available processes is either multiprocessing.cpu_count()
    and in case of windows, this never can be higher then 61

    """

    def __init__(self, msis, n_processes=None, maxtasksperchild=None, **kwargs):
        super().__init__(msis, **kwargs)

        self._pool = None

        # Calculate n_processes if negative value is inputted
        max_processes = multiprocessing.cpu_count()
        if sys.platform == "win32":
            # on windows the max number of processes is currently
            # still limited to 61
            max_processes = min(max_processes, 61)

        if isinstance(n_processes, int):
            if n_processes > 0:
                if max_processes > n_processes:
                    warnings.warn(f"the number of processes cannot be more then {max_processes}")
                self.n_processes = min(n_processes, max_processes)
            else:
                self.n_processes = max(max_processes + n_processes, 1)
        elif n_processes is None:
            self.n_processes = max_processes
        else:
            raise ValueError("max_processes must be an integer or None")

        self.maxtasksperchild = maxtasksperchild

    def initialize(self):
        log_queue = multiprocessing.Queue()

        log_queue_reader = LogQueueReader(log_queue)
        log_queue_reader.start()

        try:
            loglevel = ema_logging._rootlogger.getEffectiveLevel()
        except AttributeError:
            loglevel = 30

        # check if we need a working directory
        for model in self._msis:
            try:
                model.working_directory
            except AttributeError:
                self.root_dir = None
                break
        else:
            random_part = [random.choice(string.ascii_letters + string.digits) for _ in range(5)]
            random_part = "".join(random_part)
            self.root_dir = os.path.abspath("tmp" + random_part)
            os.makedirs(self.root_dir)

        self._pool = multiprocessing.Pool(
            self.n_processes,
            initializer,
            (self._msis, log_queue, loglevel, self.root_dir),
            self.maxtasksperchild,
        )
        self.n_processes = self._pool._processes
        _logger.info(f"pool started with {self.n_processes} workers")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        _logger.info("terminating pool")

        if exc_type is not None:
            # When an exception is thrown stop accepting new jobs
            # and abort pending jobs without waiting.
            self._pool.terminate()
            return False

        super().__exit__(exc_type, exc_value, traceback)

    def finalize(self):
        # Stop accepting new jobs and wait for pending jobs to finish.
        self._pool.close()
        self._pool.join()

        if self.root_dir:
            shutil.rmtree(self.root_dir)

    def evaluate_experiments(self, scenarios, policies, callback, combine="factorial"):
        ex_gen = experiment_generator(scenarios, self._msis, policies, combine=combine)
        add_tasks(self.n_processes, self._pool, ex_gen, callback)

class IpyparallelEvaluator(BaseEvaluator):
    """evaluator for using an ipypparallel pool"""

    def __init__(self, msis, client, **kwargs):
        super().__init__(msis, **kwargs)
        self.client = client

    def initialize(self):
        import ipyparallel

        _logger.debug("starting ipyparallel pool")

        try:
            TIMEOUT_MAX = threading.TIMEOUT_MAX
        except AttributeError:
            TIMEOUT_MAX = 1e10  # noqa
        ipyparallel.client.asyncresult._FOREVER = TIMEOUT_MAX
        # update loggers on all engines
        self.client[:].apply_sync(set_engine_logger)

        _logger.debug("initializing engines")
        initialize_engines(self.client, self._msis, os.getcwd())

        self.logwatcher, self.logwatcher_thread = start_logwatcher()

        _logger.debug("successfully started ipyparallel pool")
        _logger.info("performing experiments using ipyparallel")

        return self

    def finalize(self):
        self.logwatcher.stop()
        cleanup(self.client)

    def evaluate_experiments(self, scenarios, policies, callback, combine="factorial"):
        ex_gen = experiment_generator(scenarios, self._msis, policies, combine=combine)

        lb_view = self.client.load_balanced_view()
        results = lb_view.map(_run_experiment, ex_gen, ordered=False, block=False)

        for entry in results:
            callback(*entry)

def perform_experiments(
    models,
    scenarios=0,
    policies=0,
    evaluator=None,
    reporting_interval=None,
    reporting_frequency=10,
    uncertainty_union=False,
    lever_union=False,
    outcome_union=False,
    uncertainty_sampling=Samplers.LHS,
    lever_sampling=Samplers.LHS,
    callback=None,
    return_callback=False,
    combine="factorial",
    log_progress=False,
):
    """sample uncertainties and levers, and perform the resulting experiments
    on each of the models

    Parameters
    ----------
    models : one or more AbstractModel instances
    scenarios : int or collection of Scenario instances, optional
    policies :  int or collection of Policy instances, optional
    evaluator : Evaluator instance, optional
    reporting_interval : int, optional
    reporting_frequency: int, optional
    uncertainty_union : boolean, optional
    lever_union : boolean, optional
    outcome_union : boolean, optional
    uncertainty_sampling : {LHS, MC, FF, PFF, SOBOL, MORRIS, FAST}, optional
    lever_sampling : {LHS, MC, FF, PFF, SOBOL, MORRIS, FAST}, optional TODO:: update doc
    callback  : Callback instance, optional
    return_callback : boolean, optional
    log_progress : bool, optional
    combine : {'factorial', 'zipover'}, optional
              how to combine uncertainties and levers?
              In case of 'factorial', both are sampled separately using their
              respective samplers. Next the resulting designs are combined in a
              full factorial manner.
              In case of 'zipover', both are sampled separately and
              then combined by cycling over the shortest of the the two sets
              of designs until the longest set of designs is exhausted.

    Returns
    -------
    tuple
        the experiments as a dataframe, and a dict
        with the name of an outcome as key, and the associated values
        as numpy array. Experiments and outcomes are aligned on index.

    """
    # TODO:: break up in to helper functions
    # unreadable in this form

    if not scenarios and not policies:
        raise EMAError("no experiments possible since both " "scenarios and policies are 0")

    scenarios, uncertainties, n_scenarios = setup_scenarios(
        scenarios, uncertainty_sampling, uncertainty_union, models
    )
    policies, levers, n_policies = setup_policies(policies, lever_sampling, lever_union, models)

    try:
        n_models = len(models)
    except TypeError:
        n_models = 1

    outcomes = determine_objects(models, "outcomes", union=outcome_union)

    if combine == "factorial":
        nr_of_exp = n_models * n_scenarios * n_policies

        # TODO:: change to 0 policies / 0 scenarios is sampling set to 0 for
        # it
        _logger.info(
            ("performing {} scenarios * {} policies * {} model(s) = " "{} experiments").format(
                n_scenarios, n_policies, n_models, nr_of_exp
            )
        )
    else:
        nr_of_exp = n_models * max(n_scenarios, n_policies)
        # TODO:: change to 0 policies / 0 scenarios is sampling set to 0 for
        # it
        _logger.info(
            ("performing max({} scenarios, {} policies) * {} model(s) = " "{} experiments").format(
                n_scenarios, n_policies, n_models, nr_of_exp
            )
        )

    callback = setup_callback(
        callback,
        uncertainties,
        levers,
        outcomes,
        nr_of_exp,
        reporting_interval,
        reporting_frequency,
        log_progress,
    )

    if not evaluator:
        evaluator = SequentialEvaluator(models)

    evaluator.evaluate_experiments(scenarios, policies, callback, combine=combine)

    if callback.i != nr_of_exp:
        raise EMAError(
            (
                "some fatal error has occurred while "
                "running the experiments, not all runs have "
                "completed. expected {}, got {}"
            ).format(nr_of_exp, callback.i)
        )

    _logger.info("experiments finished")

    if return_callback:
        return callback

    results = callback.get_results()
    return results

def setup_callback(
    callback,
    uncertainties,
    levers,
    outcomes,
    nr_of_exp,
    reporting_interval,
    reporting_frequency,
    log_progress,
):
    if not callback:
        callback = DefaultCallback(
            uncertainties,
            levers,
            outcomes,
            nr_of_exp,
            reporting_interval=reporting_interval,
            reporting_frequency=reporting_frequency,
            log_progress=log_progress,
        )
    else:
        callback = callback(
            uncertainties,
            levers,
            outcomes,
            nr_of_exp,
            reporting_interval=reporting_interval,
            reporting_frequency=reporting_frequency,
            log_progress=log_progress,
        )
    return callback

def setup_policies(policies, levers_sampling, lever_union, models):
    if not policies:
        policies = [Policy("None", **{})]
        levers = []
        n_policies = 1
    elif isinstance(policies, numbers.Integral):
        sampler = levers_sampling

        if not isinstance(sampler, AbstractSampler):
            sampler = sampler.value

        policies = sample_levers(models, policies, union=lever_union, sampler=sampler)
        levers = policies.parameters
        n_policies = policies.n
    else:
        try:
            levers = policies.parameters
            n_policies = policies.n
        except AttributeError:
            levers = determine_objects(models, "levers", union=True)
            if isinstance(policies, Policy):
                policies = [policies]

            levers = [l for l in levers if l.name in policies[0]]
            n_policies = len(policies)
    return policies, levers, n_policies

def setup_scenarios(scenarios, uncertainty_sampling, uncertainty_union, models):
    if not scenarios:
        scenarios = [Scenario("None", **{})]
        uncertainties = []
        n_scenarios = 1
    elif isinstance(scenarios, numbers.Integral):
        sampler = uncertainty_sampling
        if not isinstance(sampler, AbstractSampler):
            sampler = sampler.value
        scenarios = sample_uncertainties(
            models, scenarios, sampler=sampler, union=uncertainty_union
        )
        uncertainties = scenarios.parameters
        n_scenarios = scenarios.n
    else:
        try:
            uncertainties = scenarios.parameters
            n_scenarios = scenarios.n
        except AttributeError:
            uncertainties = determine_objects(models, "uncertainties", union=True)
            if isinstance(scenarios, Scenario):
                scenarios = [scenarios]

            uncertainties = [u for u in uncertainties if u.name in scenarios[0]]
            n_scenarios = len(scenarios)
    return scenarios, uncertainties, n_scenarios

def optimize(
    models,
    algorithm=EpsNSGAII,
    nfe=10000,
    searchover="levers",
    evaluator=None,
    reference=None,
    convergence=None,
    constraints=None,
    convergence_freq=1000,
    logging_freq=5,
    variator=None,
    **kwargs,
):
    """optimize the model

    Parameters
    ----------
    models : 1 or more Model instances
    algorithm : a valid Platypus optimization algorithm
    nfe : int
    searchover : {'uncertainties', 'levers'}
    evaluator : evaluator instance
    reference : Policy or Scenario instance, optional
                overwrite the default scenario in case of searching over
                levers, or default policy in case of searching over
                uncertainties
    convergence : function or collection of functions, optional
    constraints : list, optional
    convergence_freq :  int
                        nfe between convergence check
    logging_freq : int
                   number of generations between logging of progress
    variator : platypus GAOperator instance, optional
               if None, it falls back on the defaults in platypus-opts
               which is SBX with PM
    kwargs : any additional arguments will be passed on to algorithm

    Returns
    -------
    pandas DataFrame

    Raises
    ------
    EMAError if searchover is not one of 'uncertainties' or 'levers'
    NotImplementedError if len(models) > 1

    """
    if searchover not in ("levers", "uncertainties"):
        raise EMAError(
            "searchover should be one of 'levers' or" "'uncertainties' not {}".format(searchover)
        )

    try:
        if len(models) == 1:
            models = models[0]
        else:
            raise NotImplementedError("optimization over multiple" "models yet supported")
    except TypeError:
        pass

    problem = to_problem(models, searchover, constraints=constraints, reference=reference)

    # solve the optimization problem
    if not evaluator:
        evaluator = SequentialEvaluator(models)

    return _optimize(
        problem,
        evaluator,
        algorithm,
        convergence,
        nfe,
        convergence_freq,
        logging_freq,
        variator=variator,
        **kwargs,
    )

def robust_optimize(
    model,
    robustness_functions,
    scenarios,
    evaluator=None,
    algorithm=EpsNSGAII,
    nfe=10000,
    convergence=None,
    constraints=None,
    convergence_freq=1000,
    logging_freq=5,
    **kwargs,
):
    """perform robust optimization

    Parameters
    ----------
    model : model instance
    robustness_functions : collection of ScalarOutcomes
    scenarios : int, or collection
    evaluator : Evaluator instance
    algorithm : platypus Algorithm instance
    nfe : int
    convergence : list
                  list of convergence metrics
    constraints : list
    convergence_freq :  int
                        nfe between convergence check
    logging_freq : int
                   number of generations between logging of progress
    kwargs : any additional arguments will be passed on to algorithm

    Raises
    ------
    AssertionError if robustness_function is not a ScalarOutcome,
    if robustness_function.kind is INFO, or
    if robustness_function.function is None

    robustness functions are scalar outcomes, kind should be MINIMIZE or
    MAXIMIZE, function is the robustness function you want to use.

    """
    for rf in robustness_functions:
        assert isinstance(rf, ScalarOutcome)
        assert rf.kind != AbstractOutcome.INFO
        assert rf.function is not None

    problem = to_robust_problem(
        model, scenarios, constraints=constraints, robustness_functions=robustness_functions
    )

    # solve the optimization problem
    if not evaluator:
        evaluator = SequentialEvaluator(model)

    return _optimize(
        problem,
        evaluator,
        algorithm,
        convergence,
        int(nfe),
        convergence_freq,
        logging_freq,
        **kwargs,
    )


text:
void vscSourceCodeViewerOwner_SetOwner(const IVscSourceCodeViewerOwner* pOwner)
{
    vspSourceCodeViewer& pInstance = vspSourceCodeViewer::instance();
    pInstance.setOwner(pOwner);
}


text:
// -*- coding: utf-8 -*-

#include <uc/uc.h>
#include "libtpm/libtpm.h"
#include "libtpm/tpmutils.h"
#include "core.h"

TSS_RESULT LIBTPMCALL TCS_GetRandom(UINT32 locality, BYTE * buffer, UINT32 size)
{
	UINT64 offset = 0;
	TSS_RESULT result;
	UINT32 paramSize;
	BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
	UINT32 bytesReturned;
	BYTE * tmpbuf = 0;

   if(LIBTPM_IsInit() == false) {
      LOGERROR("libtpm not initialized");
      return TCSERR(TSS_E_INTERNAL_ERROR);
   }

	LOGDEBUG("Entering TCS_GetRandom");

   result = tpm_rqu_build(TPM_ORD_GetRandom, &offset, txBlob, size, NULL);
	if(result) {
		LOGDEBUG("tpm_rqu_build returns %x", result);
		return result;
	}

   UnloadBlob_Header(txBlob, &paramSize);
	result = tpm_io(locality, txBlob, paramSize, txBlob, sizeof(txBlob));
	if(result) {
	   result = TDDLERR(result);
		LOGERROR("tpm_io returns %x", result);
		return result;
	}

	result = UnloadBlob_Header(txBlob, &paramSize);
	if(! result) {
		result = tpm_rsp_parse(TPM_ORD_GetRandom, txBlob, paramSize, &bytesReturned, &tmpbuf, NULL, NULL);
	}

	memcpy(buffer, tmpbuf, MIN(bytesReturned, size));
	free(tmpbuf);

	LOGDEBUG("Exiting TCS_GetRandom : %x", result);

	return result;
}

TSS_RESULT LIBTPMCALL TCS_StirRandom(UINT32 locality, BYTE * buffer, UINT32 size)
{
	UINT64 offset = 0;
	TSS_RESULT result;
	UINT32 paramSize;
	BYTE txBlob[TSS_TPM_TXBLOB_SIZE];
	//UINT32 bytesReturned;
	//BYTE * tmpbuf = 0;

   if(LIBTPM_IsInit() == false) {
      LOGERROR("libtpm not initialized");
      return TCSERR(TSS_E_INTERNAL_ERROR);
   }

	LOGDEBUG("Entering TCS_StirRandom");

   result = tpm_rqu_build(TPM_ORD_StirRandom, &offset, txBlob, size, size, buffer);
	if(result) {
		LOGDEBUG("tpm_rqu_build returns %x", result);
		return result;
	}

   UnloadBlob_Header(txBlob, &paramSize);
	result = tpm_io(locality, txBlob, paramSize, txBlob, sizeof(txBlob));
	if(result) {
	   result = TDDLERR(result);
		LOGERROR("tpm_io returns %x", result);
		return result;
	}

	result = UnloadBlob_Header(txBlob, &paramSize);
	LOGDEBUG("Exiting TCS_StirRandom : %x", result);

	return result;
}


text:
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/*!
 * Next JS
 * Copyright (c)2011 Xenophy.CO.,LTD All rights Reserved.
 * http://www.xenophy.com
 */

// {{{ NX.smtp.message.Stream.destroy

module.exports = function() {

   this.stopped = true;

};

// }}}

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */


text:
title: Pushing data using the WebSocket interface
layout: function
isPage: true
oldPath: 21-websocket-push.html.md.eco
category: howto
---

The Warp platform offers an alternative to the standard [POST](pushing-data) interface for pushing data.

This alternate write path is based on HTML5 [WebSockets](https://en.wikipedia.org/wiki/WebSocket).

The WebSocket endpoint is `wss://API_ENDPOINT/api/vX/streamupdate`, where `API_ENDPOINT` is a [valid endpoint](../api/endpoints).

The WebSocket interface supports individual messages of up to 1000000 bytes. Each message is transmitted in a dedicated WebSocket frame.

## Valid WebSocket messages ##

### Token specification ###

```
   TOKEN <token>
```

This message sets the current write token for the WebSocket connection.

### Token reset ###

```
   CLEARTOKEN
```

This message resets the current write token. Any data update attempt will fail until `TOKEN <token>` is called first.

### No Operation ###

```
   NOOP
```

This message does nothing apart from keeping the connection alive.

### Error handling ###

```
   ONERROR MESSAGE|CLOSE
```

Sets the error handling mode. If 'MESSAGE' is specified, errors will generate a WebSocket message of the format `ERROR message` but will leave the connection open. If 'CLOSE' is specified, errors will throw an exception and will close the connection. The default error handling mode is 'CLOSE'.

### Data update ###

```
   TS/LAT:LON/ELEV class{labels} VALUE
   ...
```

This message pushes the given data using the current write token. The format of this message is the same as the one accepted by the [POST](pushing-data) endpoint.

## Responses ##

After successfull execution of one of the messages above, a response message with the following syntax is sent:

```
   OK <seqno> ...
```

Depending on the error handling mode set via `ONERROR`, a failed operation will either lead to an `ERROR ...` message or to an exception which will close the WebSocket.


text:
/* eslint-env mocha */
import { compileDirectory } from './helper'

describe('TypeScript definitions for http', function() {
  this.timeout(15000)
  it('should compile against index.d.ts', compileDirectory)
})


text:
ACCEPTED

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

#### Published in
Hedwigia 23: 7 (1884)

#### Original name
Fusidium adoxae Rabenh., 1857

### Remarks
null


text:
<?xml version="1.0" encoding="UTF-8"?>
<enunciate label="axiom-service-api"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://enunciate.webcohesion.com/schemas/enunciate-2.0.0.xsd">

    <api-classes>
        <include pattern="org.axiom_tools.storage.**" />
        <include pattern="org.axiom_tools.domain.**" />
        <include pattern="org.axiom_tools.faces.**" />
    </api-classes>

    <namespaces>
        <namespace id="axiom-models" uri="http://api.axiom-tools.com/axiom-models"/>
        <namespace id="axiom-storage" uri="http://api.axiom-tools.com/axiom-storage"/>
        <namespace id="axiom-facades" uri="http://api.axiom-tools.com/axiom-facades"/>
    </namespaces>

    <modules>
        <c-xml-client disabled="true" />
        <csharp-xml-client disabled="true" />
        <!--<docs />-->
        <gwt-json-overlay disabled="true" />
        <idl disabled="true" />
        <!--<jackson disabled="false" />-->
        <jackson1 disabled="true" />
        <java-json-client disabled="true" />
        <java-xml-client disabled="true" />
        <jaxb disabled="true" />
        <jaxws disabled="true" />
        <obj-c-xml-client disabled="true" />
        <php-json-client disabled="true" />
        <php-xml-client disabled="true" />
        <ruby-json-client disabled="true" />
        <!--<swagger />-->

        <jaxrs groupBy="class">
            <application path="api" />
        </jaxrs>

    </modules>

    <disable-rule id="all.warnings" />
    <webapp disabled="true" />

</enunciate>


text:
{{title}}

			<nof-action-bar [actions]="actionHolders"></nof-action-bar>

{{message}}

			<form (ngSubmit)="onSubmit()" [formGroup]="form" autocomplete="off">
				<ng-container *ngFor="let parmprop of parametersProperties">
					<nof-edit-parameter *ngIf="isParameter(parmprop)" [ngClass]="classes(asParameter(parmprop))" [parameter]="asParameter(parmprop)" [parent]="parentMenu" [form]="form"></nof-edit-parameter>
					<nof-view-property *ngIf="isProperty(parmprop)" [propertyName]="asProperty(parmprop)" class="property"></nof-view-property>
				</ng-container>

{{message}}

			</form>


text:
require 'spec_helper'

module Spree
  module Stock
    describe AvailabilityValidator, :type => :model do
      context "line item has no parts" do
        let!(:line_item) { create(:line_item, quantity: 5) }
        let!(:product) { line_item.product }

        subject { described_class.new }

        it 'should be valid when supply is sufficient' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(true)
          expect(line_item).not_to receive(:errors)
          subject.validate(line_item)
        end

        it 'should be invalid when supply is insufficent' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
          expect(line_item.errors).to receive(:[]).exactly(1).times.with(:quantity).and_return([])
          subject.validate(line_item)
        end

        it 'should consider existing inventory_units sufficient' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
          allow(line_item.inventory_units).to receive_messages(where: [double] * 5)
          expect(line_item).not_to receive(:errors)
          subject.validate(line_item)
        end
      end

      context "line item has parts" do
        let!(:order) { create(:order_with_line_items) }
        let(:line_item) { order.line_items.first }
        let(:product) { line_item.product }
        let(:variant) { line_item.variant }
        let(:parts) { (1..2).map { create(:variant) } }
        before { product.parts << parts }

        subject { described_class.new }

        it 'should be valid when supply of all parts is sufficient' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(true)
          expect(line_item).not_to receive(:errors)
          subject.validate(line_item)
        end

        it 'should be invalid when supplies of all parts are insufficent' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
          expect(line_item.errors).to receive(:[]).exactly(line_item.parts.size).times.with(:quantity).and_return([])
          subject.validate(line_item)
        end

        it 'should be invalid when supply of 1 part is insufficient' do
          allow_any_instance_of(Stock::Quantifier).to receive(:can_supply?).and_return(false)
          inventory_units = [double(variant: line_item.parts.first)] * 5
          allow(line_item.parts.first).to receive_messages(inventory_units: inventory_units)
          expect(line_item.inventory_units).to receive(:where).and_return(inventory_units, [])
          expect(line_item.errors).to receive(:[]).exactly(1).times.with(:quantity).and_return([])
          subject.validate(line_item)
        end

        it 'should be valid when supply of each part is sufficient' do
          line_item.parts.each { |part| allow(part).to receive_messages(inventory_units: [double(variant: part)] * 5) }
          expect(line_item).not_to receive(:errors)
          subject.validate(line_item)
        end
      end
    end
  end
end


text:
package mocks

import (
	ovfexportdomain "github.com/GoogleCloudPlatform/compute-image-tools/cli_tools/gce_ovf_export/domain"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockOvfExportParamValidator is a mock of OvfExportParamValidator interface
type MockOvfExportParamValidator struct {
	ctrl     *gomock.Controller
	recorder *MockOvfExportParamValidatorMockRecorder
}

// MockOvfExportParamValidatorMockRecorder is the mock recorder for MockOvfExportParamValidator
type MockOvfExportParamValidatorMockRecorder struct {
	mock *MockOvfExportParamValidator
}

// NewMockOvfExportParamValidator creates a new mock instance
func NewMockOvfExportParamValidator(ctrl *gomock.Controller) *MockOvfExportParamValidator {
	mock := &MockOvfExportParamValidator{ctrl: ctrl}
	mock.recorder = &MockOvfExportParamValidatorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockOvfExportParamValidator) EXPECT() *MockOvfExportParamValidatorMockRecorder {
	return m.recorder
}

// ValidateAndParseParams mocks base method
func (m *MockOvfExportParamValidator) ValidateAndParseParams(arg0 *ovfexportdomain.OVFExportArgs) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateAndParseParams", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateAndParseParams indicates an expected call of ValidateAndParseParams
func (mr *MockOvfExportParamValidatorMockRecorder) ValidateAndParseParams(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateAndParseParams", reflect.TypeOf((*MockOvfExportParamValidator)(nil).ValidateAndParseParams), arg0)
}


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package View.ModuloVentas;

import Model.Calidades;
import Model.Categorias;
import Model.Detallesproductos;
import Model.DisplayItem;
import Model.Marcas;
import Model.Productos;
import View.ModuloVentas.Opcion.AñadirVenta;
import java.util.List;
import java.util.Vector;
import javax.swing.DefaultComboBoxModel;
import javax.swing.ImageIcon;
import javax.swing.table.DefaultTableModel;

/**
 *
 * @author Alonso
 */
public class AgregarProducto extends javax.swing.JInternalFrame {
    java.util.LinkedList<Clases.ListaProductos> lista;

    /**
     * Creates new form AgregarProducto
     */
    public AgregarProducto() {
        lista = new java.util.LinkedList<>();
        initComponents();
        loadCalidades();
        loadCategorias();
        loadMarca();
        loadProducto();
        Mostrar();
    }
    void Mostrar()
    {
           for(Productos producto: Controller.ProductosController.ShowProductos())
        {
            for(Detallesproductos detalles: Controller.DetallesProductosController.showDetallesproductos())
            {
                String produc=String.valueOf(producto.getClaveProducto());
                String detallesP= String.valueOf(detalles.getProductos().getClaveProducto());
                if(produc.equalsIgnoreCase(detallesP))
                {

                            DefaultTableModel datos=(DefaultTableModel)productosjTable.getModel();
                            Vector resultado=new Vector();
                            resultado.add(detalles.getProductos().getClaveProducto());
                            resultado.add(detalles.getProductos().getNombre());
                            resultado.add(detalles.getExistencias());
                            resultado.add(detalles.getPrecioUnitario());
                            resultado.add(detalles.getProductos().getDescripcion());
                            datos.addRow(resultado);
                }
                }
        }

    }

 void loadCategorias()
    {
        DefaultComboBoxModel datos=new DefaultComboBoxModel();
        List<Categorias> resultado=Controller.CategoriasController.ShowCategorias();
        /*Se crea un objeto de tipo RecuperacionContraseña para
        * poder acceder a todos los objetos de la clase RecuperacionContraseña
        */
        for(Categorias o: resultado){
           DisplayItem d = new DisplayItem(o.getCategoria(), o.getClaveCategoria());
            datos.addElement(d);

        }
        categoriasjComboBox.setModel(datos);
    }
 public  void loadCalidades()
    {
        DefaultComboBoxModel datos=new DefaultComboBoxModel();
        List<Calidades> resultado=Controller.CalidadesController.ShowCalidades();
        /*Se crea un objeto de tipo RecuperacionContraseña para
        * poder acceder a todos los objetos de la clase RecuperacionContraseña
        */
        for(Calidades o: resultado){
           DisplayItem d = new DisplayItem(o.getCalidad(), o.getClaveCalidad());
            datos.addElement(d);

        }
        calidadesjComboBox.setModel(datos);
    }
 public  void loadProducto()
    {
        DefaultComboBoxModel datos=new DefaultComboBoxModel();
        List<Productos> resultado=Controller.ProductosController.ShowProductos();
        /*Se crea un objeto de tipo RecuperacionContraseña para
        * poder acceder a todos los objetos de la clase RecuperacionContraseña
        */
        for(Productos  o: resultado){
           DisplayItem d = new DisplayItem(o.getNombre(), o.getClaveProducto());
            datos.addElement(d);

        }
        productosjComboBox.setModel(datos);
    }
 public  void loadMarca()
    {
        DefaultComboBoxModel datos=new DefaultComboBoxModel();
        List<Marcas> resultado=Controller.MarcasController.ShowMarcas();
        /*Se crea un objeto de tipo RecuperacionContraseña para
        * poder acceder a todos los objetos de la clase RecuperacionContraseña
        */
        for(Marcas o: resultado){
           DisplayItem d = new DisplayItem(o.getMarca(), o.getClaveMarca());
            datos.addElement(d);

        }
        marcasjComboBox.setModel(datos);
    }
 public void Listar(){
        javax.swing.DefaultListModel modelo;
        modelo= new javax.swing.DefaultListModel();
        for (int i = 0; i < lista.size(); i++)
        {
            modelo.addElement("Codigo: "+lista.get(i).getId()+" Producto: "+lista.get(i).getProducto()+" Cantidad: "+lista.get(i).getCantidad());
            AñadirVenta.productosjList.setModel(modelo);
        }
 }
 public void Subtotal()
 {
        double sumatoria = 0;
        for (int i = 0; i < lista.size(); i++) {
            sumatoria=sumatoria+lista.get(i).getCantidad();
        }
        AñadirVenta.subtotaljTextField.setText(String.valueOf(sumatoria));
 }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        panel3 = new org.edisoncor.gui.panel.Panel();
        jLabel1 = new javax.swing.JLabel();
        categoriasjComboBox = new javax.swing.JComboBox();
        jLabel2 = new javax.swing.JLabel();
        productosjComboBox = new javax.swing.JComboBox();
        jLabel3 = new javax.swing.JLabel();
        marcasjComboBox = new javax.swing.JComboBox();
        jScrollPane1 = new javax.swing.JScrollPane();
        productosjTable = new javax.swing.JTable();
        imapanel = new org.edisoncor.gui.panel.Panel();
        jButton1 = new javax.swing.JButton();
        jLabel4 = new javax.swing.JLabel();
        calidadesjComboBox = new javax.swing.JComboBox();
        jButton2 = new javax.swing.JButton();
        jLabel5 = new javax.swing.JLabel();
        cantidadjSpinner = new javax.swing.JSpinner();

        setClosable(true);

        panel3.setBackground(new java.awt.Color(255, 255, 255));
        panel3.setIcon(new javax.swing.ImageIcon(getClass().getResource("/View/Ima/Fondo.png"))); // NOI18N

        jLabel1.setText("Categoria:");

        categoriasjComboBox.setEnabled(false);

        jLabel2.setText("Producto:");

        productosjComboBox.setEnabled(false);

        jLabel3.setText("Marca:");

        marcasjComboBox.setEnabled(false);

        productosjTable.setModel(new javax.swing.table.DefaultTableModel(
            new Object [][] {

            },
            new String [] {
                "Codigo", "Producto", "Existencias", "Precio", "Descripcion"
            }
        ) {
            boolean[] canEdit = new boolean [] {
                false, false, false, false, false
            };

            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return canEdit [columnIndex];
            }
        });
        productosjTable.addMouseListener(new java.awt.event.MouseAdapter() {
            public void mouseClicked(java.awt.event.MouseEvent evt) {
                productosjTableMouseClicked(evt);
            }
        });
        jScrollPane1.setViewportView(productosjTable);
        productosjTable.getColumnModel().getColumn(0).setResizable(false);
        productosjTable.getColumnModel().getColumn(1).setResizable(false);
        productosjTable.getColumnModel().getColumn(2).setResizable(false);
        productosjTable.getColumnModel().getColumn(3).setResizable(false);
        productosjTable.getColumnModel().getColumn(4).setResizable(false);

        javax.swing.GroupLayout imapanelLayout = new javax.swing.GroupLayout(imapanel);
        imapanel.setLayout(imapanelLayout);
        imapanelLayout.setHorizontalGroup(
            imapanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 186, Short.MAX_VALUE)
        );
        imapanelLayout.setVerticalGroup(
            imapanelLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGap(0, 131, Short.MAX_VALUE)
        );

        jButton1.setIcon(new javax.swing.ImageIcon(getClass().getResource("/ima/agregar.png"))); // NOI18N
        jButton1.setText("Agregar");
        jButton1.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        jButton1.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        jLabel4.setText("Calidad:");

        calidadesjComboBox.setEnabled(false);

        jButton2.setIcon(new javax.swing.ImageIcon(getClass().getResource("/ima/Eliminar.png"))); // NOI18N
        jButton2.setText("Remover");
        jButton2.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        jButton2.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });

        jLabel5.setText("Cantidad:");

        cantidadjSpinner.setModel(new javax.swing.SpinnerNumberModel(1, 1, 200, 1));

        javax.swing.GroupLayout panel3Layout = new javax.swing.GroupLayout(panel3);
        panel3.setLayout(panel3Layout);
        panel3Layout.setHorizontalGroup(
            panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(panel3Layout.createSequentialGroup()
                .addGap(189, 189, 189)
                .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(jLabel3)
                    .addComponent(jLabel2)
                    .addComponent(jLabel1)
                    .addComponent(jLabel4)
                    .addComponent(jLabel5))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(panel3Layout.createSequentialGroup()
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(calidadesjComboBox, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addGroup(panel3Layout.createSequentialGroup()
                                .addComponent(jButton1)
                                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                                .addComponent(jButton2)
                                .addGap(0, 0, Short.MAX_VALUE)))
                        .addGap(48, 48, 48))
                    .addGroup(panel3Layout.createSequentialGroup()
                        .addComponent(cantidadjSpinner, javax.swing.GroupLayout.PREFERRED_SIZE, 168, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                .addComponent(imapanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(47, Short.MAX_VALUE))
            .addComponent(jScrollPane1)
            .addGroup(panel3Layout.createSequentialGroup()
                .addGap(244, 244, 244)
                .addComponent(marcasjComboBox, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addGap(281, 281, 281))
            .addGroup(panel3Layout.createSequentialGroup()
                .addGap(244, 244, 244)
                .addComponent(productosjComboBox, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addGap(281, 281, 281))
            .addGroup(panel3Layout.createSequentialGroup()
                .addGap(244, 244, 244)
                .addComponent(categoriasjComboBox, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addGap(281, 281, 281))
        );
        panel3Layout.setVerticalGroup(
            panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(panel3Layout.createSequentialGroup()
                .addGap(23, 23, 23)
                .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                    .addGroup(panel3Layout.createSequentialGroup()
                        .addComponent(imapanel, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addGap(80, 80, 80))
                    .addGroup(panel3Layout.createSequentialGroup()
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jLabel1)
                            .addComponent(categoriasjComboBox, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jLabel2)
                            .addComponent(productosjComboBox, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jLabel3)
                            .addComponent(marcasjComboBox, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jLabel4)
                            .addComponent(calidadesjComboBox, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                            .addComponent(jLabel5)
                            .addComponent(cantidadjSpinner, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addGroup(panel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(jButton1)
                            .addComponent(jButton2))
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)))
                .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 318, Short.MAX_VALUE))
        );

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(panel3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(panel3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(0, 16, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void productosjTableMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_productosjTableMouseClicked
        for(Productos producto: Controller.ProductosController.ShowProductos())
        {
            for(Detallesproductos detalles: Controller.DetallesProductosController.showDetallesproductos())
            {
                String produc=String.valueOf(producto.getClaveProducto());
                String detallesP= String.valueOf(detalles.getProductos().getClaveProducto());
                    if(produc.equalsIgnoreCase(detallesP))
                    {
                        int selected = productosjTable.getSelectedRow();
                        String codigo=productosjTable.getValueAt(selected, 0).toString();
                        if(codigo.equalsIgnoreCase(produc))
                        {
                            categoriasjComboBox.setSelectedItem(detalles.getCategorias().getCategoria());
                            productosjComboBox.setSelectedItem(detalles.getProductos().getNombre());
                            calidadesjComboBox.setSelectedItem(detalles.getCalidades().getCalidad());
                            cantidadjSpinner.setValue(detalles.getExistencias());
                            marcasjComboBox.setSelectedItem(detalles.getMarcas().getMarca());
                            imapanel.setIcon(new ImageIcon(detalles.getProductos().getImagen()));
                            imapanel.removeAll();
                            imapanel.updateUI();
                        }
                    }
                }
        }
    }//GEN-LAST:event_productosjTableMouseClicked

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
        for(Productos producto: Controller.ProductosController.ShowProductos())
        {
            for(Detallesproductos detalles: Controller.DetallesProductosController.showDetallesproductos())
            {
                String produc=String.valueOf(producto.getClaveProducto());
                String detallesP= String.valueOf(detalles.getProductos().getClaveProducto());
                    if(produc.equalsIgnoreCase(detallesP))
                    {
                        int selected = productosjTable.getSelectedRow();
                        String codigo=productosjTable.getValueAt(selected, 0).toString();
                        if(codigo.equalsIgnoreCase(produc))
                        {
                            String nombreProducto=productosjTable.getValueAt(selected, 1).toString();
                            int cantidad =Integer.parseInt(cantidadjSpinner.getValue().toString());
                            float precio = Float.parseFloat(productosjTable.getValueAt(selected, 3).toString());
                            lista.add(new Clases.ListaProductos(producto.getClaveProducto(), producto.getNombre(),cantidad, precio));
                            Listar();
                            dispose();
                        }
                    }
                }
        }

    }//GEN-LAST:event_jButton1ActionPerformed

    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed
        lista.removeFirst();
        Listar();
        dispose();
    }//GEN-LAST:event_jButton2ActionPerformed

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JComboBox calidadesjComboBox;
    private javax.swing.JSpinner cantidadjSpinner;
    private javax.swing.JComboBox categoriasjComboBox;
    private org.edisoncor.gui.panel.Panel imapanel;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JLabel jLabel5;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JComboBox marcasjComboBox;
    private org.edisoncor.gui.panel.Panel panel3;
    private javax.swing.JComboBox productosjComboBox;
    private javax.swing.JTable productosjTable;
    // End of variables declaration//GEN-END:variables
}


text:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<schema>

        <key>
            <keyPart name="createMeKeyPart1" type="String" length="15" inverted="false" />
            <keyPart name="createMeKeyPart2" type="Timestamp" length="15" inverted="true"  />
        </key>
        <columnFamilies>
	        <columnFamily name="createMeColumnFamily1"
	            maxVersions="3"
	            blockSizeKB="64"
	            blockCache="true"
	            timeToLiveMS="2147483647"
	            inMemory="false"
	            bloomFilter="NONE"
	            replicationScope="0">
                <column name="createMeColumn1" type="String" />
                <column name="createMeColumn2" type="Timestamp" />
                <column name="createMeColumn3" type="Byte" />
	        </columnFamily>
        </columnFamilies>

        <key>
            <keyPart name="alterMeKeyPart1" type="String" length="15" inverted="false" />
            <keyPart name="alterMeKeyPart2" type="Timestamp" length="15" inverted="true"  />
        </key>
        <columnFamilies>
	        <columnFamily name="alterMeColumnFamily1"
	            maxVersions="3"
	            blockSizeKB="65"
	            blockCache="true"
	            timeToLiveMS="2147483647"
	            inMemory="false"
	            bloomFilter="NONE"
	            replicationScope="0">
                <column name="alterMeColumn1" type="String" />
                <column name="alterMeColumn2" type="Timestamp" />
                <column name="alterMeColumn3" type="Byte" />
	        </columnFamily>
        </columnFamilies>

        <key>
            <keyPart name="ignoreMeKeyPart1" type="String" length="15" inverted="false" />
            <keyPart name="ignoreMeKeyPart2" type="Timestamp" length="15" inverted="true"  />
        </key>
        <columnFamilies>
	        <columnFamily name="ignoreMeColumnFamily1"
	            maxVersions="3"
	            blockSizeKB="64"
	            blockCache="true"
	            timeToLiveMS="2147483647"
	            inMemory="false"
	            bloomFilter="NONE"
	            replicationScope="0">
                <column name="ignoreMeColumn1" type="String" />
                <column name="ignoreMeColumn2" type="Timestamp" />
                <column name="ignoreMeColumn3" type="Byte" />
	        </columnFamily>
        </columnFamilies>

</schema>


text:
package org.maltparser.core.io.dataformat;
/**
 *  DataFormatEntry is used for storing information about one column in a data format.
 *
 * @author Johan Hall
 * @since 1.0
**/
public class DataFormatEntry {
	/** Column name */
	private String dataFormatEntryName;
	/** Column category (INPUT, HEAD, DEPENDENCY_EDGE_LABEL, PHRASE_STRUCTURE_EDGE_LABEL, PHRASE_STRUCTURE_NODE_LABEL, SECONDARY_EDGE_LABEL, IGNORE and INTERNAL) */
	private String category;
	/** Column type (STRING, INTEGER, BOOLEAN, REAL) */
	private String type;
	/** Default output for a ignore column */
	private String defaultOutput;
	/** Cache the hash code for the data format entry */
	private int cachedHash;
	/**
	 * Creates a data format entry
	 *
	 * @param dataFormatEntryName column name
	 * @param category	column category
	 * @param type	column type
	 * @param defaultOutput	default output for a ignore column
	 */
	public DataFormatEntry(String dataFormatEntryName, String category, String type, String defaultOutput) {
		setDataFormatEntryName(dataFormatEntryName);
		setCategory(category);
		setType(type);
		setDefaultOutput(defaultOutput);
	}

	/**
	 * Returns the column name
	 * @return	the column name
	 */
	public String getDataFormatEntryName() {
		return dataFormatEntryName;
	}

	/**
	 * Sets the column name
	 * @param dataFormatEntryName	column name
	 */
	public void setDataFormatEntryName(String dataFormatEntryName) {
		this.dataFormatEntryName = dataFormatEntryName.toUpperCase();
	}

	/**
	 * Returns the column category
	 *
	 * @return	the column category
	 */
	public String getCategory() {
		return category;
	}

	/**
	 * Sets the column category
	 *
	 * @param category	the column category
	 */
	public void setCategory(String category) {
		this.category = category.toUpperCase();
	}

	/**
	 * Return the column type
	 *
	 * @return	the column type
	 */
	public String getType() {
		return type;
	}

	/**
	 * Sets the column type
	 *
	 * @param type	the column type
	 */
	public void setType(String type) {
		this.type = type.toUpperCase();
	}

	/**
	 * Returns the default output of an ignore column
	 *
	 * @return the default output of an ignore column
	 */
	public String getDefaultOutput() {
		return defaultOutput;
	}

	/**
	 * Sets the default output of an ignore column
	 *
	 * @param defaultOutput  the default output of an ignore column
	 */
	public void setDefaultOutput(String defaultOutput) {
		this.defaultOutput = defaultOutput;
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		DataFormatEntry objC = (DataFormatEntry)obj;
		return ((dataFormatEntryName == null) ? objC.dataFormatEntryName == null : dataFormatEntryName.equals(objC.dataFormatEntryName)) &&
				((type == null) ? objC.type == null : type.equals(objC.type)) &&
				((category == null) ? objC.category == null : category.equals(objC.category)) &&
				((defaultOutput == null) ? objC.defaultOutput == null : defaultOutput.equals(objC.defaultOutput));
	}

	public int hashCode() {
		if (cachedHash == 0) {
			int hash = 7;
			hash = 31 * hash + (null == dataFormatEntryName ? 0 : dataFormatEntryName.hashCode());
			hash = 31 * hash + (null == type ? 0 : type.hashCode());
			hash = 31 * hash + (null == category ? 0 : category.hashCode());
			hash = 31 * hash + (null == defaultOutput ? 0 : defaultOutput.hashCode());
			cachedHash = hash;
		}
		return cachedHash;
	}

	public String toString() {
		final StringBuilder sb = new StringBuilder();
		sb.append(dataFormatEntryName);
		sb.append("\t");
		sb.append(category);
		sb.append("\t");
		sb.append(type);
		if (defaultOutput != null) {
			sb.append("\t");
			sb.append(defaultOutput);
		}
		return sb.toString();
	}
}


text:
package talent // import "google.golang.org/genproto/googleapis/cloud/talent/v4beta1"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import _ "google.golang.org/genproto/googleapis/api/annotations"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// An enumeration of an event attributed to the behavior of the end user,
// such as a job seeker.
type JobEvent_JobEventType int32

const (
	// The event is unspecified by other provided values.
	JobEvent_JOB_EVENT_TYPE_UNSPECIFIED JobEvent_JobEventType = 0
	// The job seeker or other entity interacting with the service has
	// had a job rendered in their view, such as in a list of search results in
	// a compressed or clipped format. This event is typically associated with
	// the viewing of a jobs list on a single page by a job seeker.
	JobEvent_IMPRESSION JobEvent_JobEventType = 1
	// The job seeker, or other entity interacting with the service, has
	// viewed the details of a job, including the full description. This
	// event doesn't apply to the viewing a snippet of a job appearing as a
	// part of the job search results. Viewing a snippet is associated with an
	// [impression][google.cloud.talent.v4beta1.JobEvent.JobEventType.IMPRESSION]).
	JobEvent_VIEW JobEvent_JobEventType = 2
	// The job seeker or other entity interacting with the service
	// performed an action to view a job and was redirected to a different
	// website for job.
	JobEvent_VIEW_REDIRECT JobEvent_JobEventType = 3
	// The job seeker or other entity interacting with the service
	// began the process or demonstrated the intention of applying for a job.
	JobEvent_APPLICATION_START JobEvent_JobEventType = 4
	// The job seeker or other entity interacting with the service
	// submitted an application for a job.
	JobEvent_APPLICATION_FINISH JobEvent_JobEventType = 5
	// The job seeker or other entity interacting with the service
	// submitted an application for a job with a single click without
	// entering information. If a job seeker performs this action, send only
	// this event to the service. Do not also send
	// [JobEventType.APPLICATION_START][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_START] or [JobEventType.APPLICATION_FINISH][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_FINISH]
	// events.
	JobEvent_APPLICATION_QUICK_SUBMISSION JobEvent_JobEventType = 6
	// The job seeker or other entity interacting with the service
	// performed an action to apply to a job and was redirected to a different
	// website to complete the application.
	JobEvent_APPLICATION_REDIRECT JobEvent_JobEventType = 7
	// The job seeker or other entity interacting with the service began the
	// process or demonstrated the intention of applying for a job from the
	// search results page without viewing the details of the job posting.
	// If sending this event, JobEventType.VIEW event shouldn't be sent.
	JobEvent_APPLICATION_START_FROM_SEARCH JobEvent_JobEventType = 8
	// The job seeker, or other entity interacting with the service, performs an
	// action with a single click from the search results page to apply to a job
	// (without viewing the details of the job posting), and is redirected
	// to a different website to complete the application. If a candidate
	// performs this action, send only this event to the service. Do not also
	// send [JobEventType.APPLICATION_START][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_START],
	// [JobEventType.APPLICATION_FINISH][google.cloud.talent.v4beta1.JobEvent.JobEventType.APPLICATION_FINISH] or [JobEventType.VIEW][google.cloud.talent.v4beta1.JobEvent.JobEventType.VIEW] events.
	JobEvent_APPLICATION_REDIRECT_FROM_SEARCH JobEvent_JobEventType = 9
	// This event should be used when a company submits an application
	// on behalf of a job seeker. This event is intended for use by staffing
	// agencies attempting to place candidates.
	JobEvent_APPLICATION_COMPANY_SUBMIT JobEvent_JobEventType = 10
	// The job seeker or other entity interacting with the service demonstrated
	// an interest in a job by bookmarking or saving it.
	JobEvent_BOOKMARK JobEvent_JobEventType = 11
	// The job seeker or other entity interacting with the service was
	// sent a notification, such as an email alert or device notification,
	// containing one or more jobs listings generated by the service.
	JobEvent_NOTIFICATION JobEvent_JobEventType = 12
	// The job seeker or other entity interacting with the service was
	// employed by the hiring entity (employer). Send this event
	// only if the job seeker was hired through an application that was
	// initiated by a search conducted through the Cloud Talent Solution
	// service.
	JobEvent_HIRED JobEvent_JobEventType = 13
	// A recruiter or staffing agency submitted an application on behalf of the
	// candidate after interacting with the service to identify a suitable job
	// posting.
	JobEvent_SENT_CV JobEvent_JobEventType = 14
	// The entity interacting with the service (for example, the job seeker),
	// was granted an initial interview by the hiring entity (employer). This
	// event should only be sent if the job seeker was granted an interview as
	// part of an application that was initiated by a search conducted through /
	// recommendation provided by the Cloud Talent Solution service.
	JobEvent_INTERVIEW_GRANTED JobEvent_JobEventType = 15
	// The job seeker or other entity interacting with the service showed
	// no interest in the job.
	JobEvent_NOT_INTERESTED JobEvent_JobEventType = 16
)

var JobEvent_JobEventType_name = map[int32]string{
	0:  "JOB_EVENT_TYPE_UNSPECIFIED",
	1:  "IMPRESSION",
	2:  "VIEW",
	3:  "VIEW_REDIRECT",
	4:  "APPLICATION_START",
	5:  "APPLICATION_FINISH",
	6:  "APPLICATION_QUICK_SUBMISSION",
	7:  "APPLICATION_REDIRECT",
	8:  "APPLICATION_START_FROM_SEARCH",
	9:  "APPLICATION_REDIRECT_FROM_SEARCH",
	10: "APPLICATION_COMPANY_SUBMIT",
	11: "BOOKMARK",
	12: "NOTIFICATION",
	13: "HIRED",
	14: "SENT_CV",
	15: "INTERVIEW_GRANTED",
	16: "NOT_INTERESTED",
}
var JobEvent_JobEventType_value = map[string]int32{
	"JOB_EVENT_TYPE_UNSPECIFIED":       0,
	"IMPRESSION":                       1,
	"VIEW":                             2,
	"VIEW_REDIRECT":                    3,
	"APPLICATION_START":                4,
	"APPLICATION_FINISH":               5,
	"APPLICATION_QUICK_SUBMISSION":     6,
	"APPLICATION_REDIRECT":             7,
	"APPLICATION_START_FROM_SEARCH":    8,
	"APPLICATION_REDIRECT_FROM_SEARCH": 9,
	"APPLICATION_COMPANY_SUBMIT":       10,
	"BOOKMARK":                         11,
	"NOTIFICATION":                     12,
	"HIRED":                            13,
	"SENT_CV":                          14,
	"INTERVIEW_GRANTED":                15,
	"NOT_INTERESTED":                   16,
}

func (x JobEvent_JobEventType) String() string {
	return proto.EnumName(JobEvent_JobEventType_name, int32(x))
}
func (JobEvent_JobEventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_event_47b077ed1a38250b, []int{1, 0}
}

// The enum represents types of client events for a candidate profile.
type ProfileEvent_ProfileEventType int32

const (
	// Default value.
	ProfileEvent_PROFILE_EVENT_TYPE_UNSPECIFIED ProfileEvent_ProfileEventType = 0
	// The profile is displayed.
	ProfileEvent_IMPRESSION ProfileEvent_ProfileEventType = 1
	// The profile is viewed.
	ProfileEvent_VIEW ProfileEvent_ProfileEventType = 2
	// The profile is bookmarked.
	ProfileEvent_BOOKMARK ProfileEvent_ProfileEventType = 3
	// Comment added to the profile.
	ProfileEvent_COMMENT_ADDED ProfileEvent_ProfileEventType = 4
	// Email sent regarding the profile.
	ProfileEvent_EMAIL_SENT ProfileEvent_ProfileEventType = 5
	// The resume of the profile is viewed.
	ProfileEvent_RESUME_VIEWED ProfileEvent_ProfileEventType = 6
	// The profile is added to a job.
	ProfileEvent_ADD_TO_JOB ProfileEvent_ProfileEventType = 7
	// The recruiter explicitly highlights that a given profile is interesting
	// enough for later review or is a good result for the search.
	ProfileEvent_POSITIVE_REACTION_TO_PROFILE ProfileEvent_ProfileEventType = 8
	// The recruiter explicitly highlights that a given profile is not
	// interesting enough for later review or is not a good result for the
	// search.
	ProfileEvent_NEGATIVE_REACTION_TO_PROFILE ProfileEvent_ProfileEventType = 9
	// The candidate is interesting enough to set up an initial screen with the
	// recruiter. This step may be skipped based on the interview process.
	ProfileEvent_SCREEN ProfileEvent_ProfileEventType = 10
)

var ProfileEvent_ProfileEventType_name = map[int32]string{
	0:  "PROFILE_EVENT_TYPE_UNSPECIFIED",
	1:  "IMPRESSION",
	2:  "VIEW",
	3:  "BOOKMARK",
	4:  "COMMENT_ADDED",
	5:  "EMAIL_SENT",
	6:  "RESUME_VIEWED",
	7:  "ADD_TO_JOB",
	8:  "POSITIVE_REACTION_TO_PROFILE",
	9:  "NEGATIVE_REACTION_TO_PROFILE",
	10: "SCREEN",
}
var ProfileEvent_ProfileEventType_value = map[string]int32{
	"PROFILE_EVENT_TYPE_UNSPECIFIED": 0,
	"IMPRESSION":                     1,
	"VIEW":                           2,
	"BOOKMARK":                       3,
	"COMMENT_ADDED":                  4,
	"EMAIL_SENT":                     5,
	"RESUME_VIEWED":                  6,
	"ADD_TO_JOB":                     7,
	"POSITIVE_REACTION_TO_PROFILE":   8,
	"NEGATIVE_REACTION_TO_PROFILE":   9,
	"SCREEN":                         10,
}

func (x ProfileEvent_ProfileEventType) String() string {
	return proto.EnumName(ProfileEvent_ProfileEventType_name, int32(x))
}
func (ProfileEvent_ProfileEventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_event_47b077ed1a38250b, []int{2, 0}
}

// An event issued when an end user interacts with the application that
// implements Cloud Talent Solution. Providing this information improves the
// quality of search and recommendation for the API clients, enabling the
// service to perform optimally. The number of events sent must be consistent
// with other calls, such as job searches, issued to the service by the client.
type ClientEvent struct {
	// Required.
	//
	// A unique ID generated in the API responses. It can be found in
	// [ResponseMetadata.request_id][google.cloud.talent.v4beta1.ResponseMetadata.request_id].
	RequestId string `protobuf:"bytes,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
	// Required.
	//
	// A unique identifier, generated by the client application.
	EventId string `protobuf:"bytes,2,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	// Required.
	//
	// The timestamp of the event.
	CreateTime *timestamp.Timestamp `protobuf:"bytes,4,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// Required.
	//
	// The detail information of a specific event type.
	//
	// Types that are valid to be assigned to Event:
	//	*ClientEvent_JobEvent
	//	*ClientEvent_ProfileEvent
	Event isClientEvent_Event `protobuf_oneof:"event"`
	// Optional.
	//
	// Extra information about this event. Used for storing information with no
	// matching field in [event][google.cloud.talent.v4beta1.event] payload, for example, user application specific
	// context or details.
	//
	// At most 20 keys are supported. The maximum total size of all keys and
	// values is 2 KB.
	ExtraInfo            map[string]string `protobuf:"bytes,7,rep,name=extra_info,json=extraInfo,proto3" json:"extra_info,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ClientEvent) Reset()         { *m = ClientEvent{} }
func (m *ClientEvent) String() string { return proto.CompactTextString(m) }
func (*ClientEvent) ProtoMessage()    {}
func (*ClientEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_47b077ed1a38250b, []int{0}
}
func (m *ClientEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClientEvent.Unmarshal(m, b)
}
func (m *ClientEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClientEvent.Marshal(b, m, deterministic)
}
func (dst *ClientEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClientEvent.Merge(dst, src)
}
func (m *ClientEvent) XXX_Size() int {
	return xxx_messageInfo_ClientEvent.Size(m)
}
func (m *ClientEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ClientEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ClientEvent proto.InternalMessageInfo

func (m *ClientEvent) GetRequestId() string {
	if m != nil {
		return m.RequestId
	}
	return ""
}

func (m *ClientEvent) GetEventId() string {
	if m != nil {
		return m.EventId
	}
	return ""
}

func (m *ClientEvent) GetCreateTime() *timestamp.Timestamp {
	if m != nil {
		return m.CreateTime
	}
	return nil
}

type isClientEvent_Event interface {
	isClientEvent_Event()
}

type ClientEvent_JobEvent struct {
	JobEvent *JobEvent `protobuf:"bytes,5,opt,name=job_event,json=jobEvent,proto3,oneof"`
}

type ClientEvent_ProfileEvent struct {
	ProfileEvent *ProfileEvent `protobuf:"bytes,6,opt,name=profile_event,json=profileEvent,proto3,oneof"`
}

func (*ClientEvent_JobEvent) isClientEvent_Event() {}

func (*ClientEvent_ProfileEvent) isClientEvent_Event() {}

func (m *ClientEvent) GetEvent() isClientEvent_Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *ClientEvent) GetJobEvent() *JobEvent {
	if x, ok := m.GetEvent().(*ClientEvent_JobEvent); ok {
		return x.JobEvent
	}
	return nil
}

func (m *ClientEvent) GetProfileEvent() *ProfileEvent {
	if x, ok := m.GetEvent().(*ClientEvent_ProfileEvent); ok {
		return x.ProfileEvent
	}
	return nil
}

func (m *ClientEvent) GetExtraInfo() map[string]string {
	if m != nil {
		return m.ExtraInfo
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ClientEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ClientEvent_OneofMarshaler, _ClientEvent_OneofUnmarshaler, _ClientEvent_OneofSizer, []interface{}{
		(*ClientEvent_JobEvent)(nil),
		(*ClientEvent_ProfileEvent)(nil),
	}
}

func _ClientEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ClientEvent)
	// event
	switch x := m.Event.(type) {
	case *ClientEvent_JobEvent:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.JobEvent); err != nil {
			return err
		}
	case *ClientEvent_ProfileEvent:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ProfileEvent); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ClientEvent.Event has unexpected type %T", x)
	}
	return nil
}

func _ClientEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ClientEvent)
	switch tag {
	case 5: // event.job_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(JobEvent)
		err := b.DecodeMessage(msg)
		m.Event = &ClientEvent_JobEvent{msg}
		return true, err
	case 6: // event.profile_event
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ProfileEvent)
		err := b.DecodeMessage(msg)
		m.Event = &ClientEvent_ProfileEvent{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ClientEvent_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ClientEvent)
	// event
	switch x := m.Event.(type) {
	case *ClientEvent_JobEvent:
		s := proto.Size(x.JobEvent)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ClientEvent_ProfileEvent:
		s := proto.Size(x.ProfileEvent)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// An event issued when a job seeker interacts with the application that
// implements Cloud Talent Solution.
type JobEvent struct {
	// Required.
	//
	// The type of the event (see [JobEventType][google.cloud.talent.v4beta1.JobEvent.JobEventType]).
	Type JobEvent_JobEventType `protobuf:"varint,1,opt,name=type,proto3,enum=google.cloud.talent.v4beta1.JobEvent_JobEventType" json:"type,omitempty"`
	// Required.
	//
	// The [job name(s)][google.cloud.talent.v4beta1.Job.name] associated with this event.
	// For example, if this is an [impression][google.cloud.talent.v4beta1.JobEvent.JobEventType.IMPRESSION] event,
	// this field contains the identifiers of all jobs shown to the job seeker.
	// If this was a [view][google.cloud.talent.v4beta1.JobEvent.JobEventType.VIEW] event, this field contains the
	// identifier of the viewed job.
	Jobs                 []string `protobuf:"bytes,2,rep,name=jobs,proto3" json:"jobs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *JobEvent) Reset()         { *m = JobEvent{} }
func (m *JobEvent) String() string { return proto.CompactTextString(m) }
func (*JobEvent) ProtoMessage()    {}
func (*JobEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_47b077ed1a38250b, []int{1}
}
func (m *JobEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_JobEvent.Unmarshal(m, b)
}
func (m *JobEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_JobEvent.Marshal(b, m, deterministic)
}
func (dst *JobEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobEvent.Merge(dst, src)
}
func (m *JobEvent) XXX_Size() int {
	return xxx_messageInfo_JobEvent.Size(m)
}
func (m *JobEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_JobEvent.DiscardUnknown(m)
}

var xxx_messageInfo_JobEvent proto.InternalMessageInfo

func (m *JobEvent) GetType() JobEvent_JobEventType {
	if m != nil {
		return m.Type
	}
	return JobEvent_JOB_EVENT_TYPE_UNSPECIFIED
}

func (m *JobEvent) GetJobs() []string {
	if m != nil {
		return m.Jobs
	}
	return nil
}

// An event issued when a profile searcher interacts with the application
// that implements Cloud Talent Solution.
type ProfileEvent struct {
	// Required.
	//
	// Type of event.
	Type ProfileEvent_ProfileEventType `protobuf:"varint,1,opt,name=type,proto3,enum=google.cloud.talent.v4beta1.ProfileEvent_ProfileEventType" json:"type,omitempty"`
	// Required.
	//
	// The [profile name(s)][google.cloud.talent.v4beta1.Profile.name] associated with this client event.
	Profiles []string `protobuf:"bytes,2,rep,name=profiles,proto3" json:"profiles,omitempty"`
	// Optional.
	//
	// The job ID associated with this client event if there is one. Leave it
	// empty if the event isn't associated with a job.
	//
	// The job ID should be consistent with the
	// [JobApplication.job.requisition_id][] in the profile.
	JobId                string   `protobuf:"bytes,3,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ProfileEvent) Reset()         { *m = ProfileEvent{} }
func (m *ProfileEvent) String() string { return proto.CompactTextString(m) }
func (*ProfileEvent) ProtoMessage()    {}
func (*ProfileEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_47b077ed1a38250b, []int{2}
}
func (m *ProfileEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProfileEvent.Unmarshal(m, b)
}
func (m *ProfileEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProfileEvent.Marshal(b, m, deterministic)
}
func (dst *ProfileEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProfileEvent.Merge(dst, src)
}
func (m *ProfileEvent) XXX_Size() int {
	return xxx_messageInfo_ProfileEvent.Size(m)
}
func (m *ProfileEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ProfileEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ProfileEvent proto.InternalMessageInfo

func (m *ProfileEvent) GetType() ProfileEvent_ProfileEventType {
	if m != nil {
		return m.Type
	}
	return ProfileEvent_PROFILE_EVENT_TYPE_UNSPECIFIED
}

func (m *ProfileEvent) GetProfiles() []string {
	if m != nil {
		return m.Profiles
	}
	return nil
}

func (m *ProfileEvent) GetJobId() string {
	if m != nil {
		return m.JobId
	}
	return ""
}

func init() {
	proto.RegisterType((*ClientEvent)(nil), "google.cloud.talent.v4beta1.ClientEvent")
	proto.RegisterMapType((map[string]string)(nil), "google.cloud.talent.v4beta1.ClientEvent.ExtraInfoEntry")
	proto.RegisterType((*JobEvent)(nil), "google.cloud.talent.v4beta1.JobEvent")
	proto.RegisterType((*ProfileEvent)(nil), "google.cloud.talent.v4beta1.ProfileEvent")
	proto.RegisterEnum("google.cloud.talent.v4beta1.JobEvent_JobEventType", JobEvent_JobEventType_name, JobEvent_JobEventType_value)
	proto.RegisterEnum("google.cloud.talent.v4beta1.ProfileEvent_ProfileEventType", ProfileEvent_ProfileEventType_name, ProfileEvent_ProfileEventType_value)
}

func init() {
	proto.RegisterFile("google/cloud/talent/v4beta1/event.proto", fileDescriptor_event_47b077ed1a38250b)
}

var fileDescriptor_event_47b077ed1a38250b = []byte{
	// 827 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
	0x14, 0xde, 0xc4, 0xf9, 0x3d, 0x49, 0xc3, 0xec, 0x68, 0x17, 0x85, 0xb0, 0x3f, 0x21, 0x02, 0x51,
	0x6e, 0x1c, 0x51, 0x90, 0x40, 0xbb, 0xdc, 0x38, 0xf6, 0x64, 0x3b, 0x6d, 0xfd, 0xc3, 0xd8, 0x0d,
	0x5a, 0x6e, 0x46, 0x4e, 0x33, 0x8d, 0x5c, 0x52, 0x4f, 0x48, 0xdc, 0x6a, 0xfb, 0x06, 0x5c, 0xf3,
	0x08, 0xbc, 0x06, 0xaf, 0xc5, 0x1d, 0x37, 0x68, 0xc6, 0x4e, 0xe5, 0xc2, 0x52, 0x55, 0x7b, 0x77,
	0x7e, 0xbe, 0xf3, 0x9d, 0xe3, 0x2f, 0x9f, 0x1d, 0xf8, 0x72, 0x29, 0xe5, 0x72, 0x25, 0xc6, 0x67,
	0x2b, 0x79, 0xb5, 0x18, 0x67, 0xf1, 0x4a, 0xa4, 0xd9, 0xf8, 0xfa, 0xdb, 0xb9, 0xc8, 0xe2, 0xaf,
	0xc7, 0xe2, 0x5a, 0xa4, 0x99, 0xb9, 0xde, 0xc8, 0x4c, 0xe2, 0x4f, 0x73, 0xa0, 0xa9, 0x81, 0x66,
	0x0e, 0x34, 0x0b, 0xe0, 0xe0, 0x59, 0xc1, 0x12, 0xaf, 0x93, 0x71, 0x9c, 0xa6, 0x32, 0x8b, 0xb3,
	0x44, 0xa6, 0xdb, 0x7c, 0x74, 0xf0, 0xb2, 0xe8, 0xea, 0x6c, 0x7e, 0x75, 0x3e, 0xce, 0x92, 0x4b,
	0xb1, 0xcd, 0xe2, 0xcb, 0x75, 0x0e, 0x18, 0xfd, 0x69, 0x40, 0xc7, 0x5e, 0x25, 0x22, 0xcd, 0x88,
	0xda, 0x88, 0x9f, 0x03, 0x6c, 0xc4, 0xaf, 0x57, 0x62, 0x9b, 0xf1, 0x64, 0xd1, 0xaf, 0x0c, 0x2b,
	0xfb, 0x6d, 0xd6, 0x2e, 0x2a, 0x74, 0x81, 0x3f, 0x81, 0x96, 0xbe, 0x4c, 0x35, 0xab, 0xba, 0xd9,
	0xd4, 0x39, 0x5d, 0xe0, 0xd7, 0xd0, 0x39, 0xdb, 0x88, 0x38, 0x13, 0x5c, 0xed, 0xe8, 0xd7, 0x86,
	0x95, 0xfd, 0xce, 0xc1, 0xc0, 0x2c, 0x6e, 0xdf, 0x1d, 0x60, 0x46, 0xbb, 0x03, 0x18, 0xe4, 0x70,
	0x55, 0xc0, 0x0e, 0xb4, 0x2f, 0xe4, 0x9c, 0x6b, 0xae, 0x7e, 0x5d, 0x8f, 0x7e, 0x61, 0xde, 0xf3,
	0xd8, 0xe6, 0x91, 0x9c, 0xeb, 0x83, 0x0f, 0x1f, 0xb1, 0xd6, 0x45, 0x11, 0xe3, 0x00, 0xf6, 0xd6,
	0x1b, 0x79, 0x9e, 0xac, 0x44, 0xc1, 0xd4, 0xd0, 0x4c, 0x5f, 0xdd, 0xcb, 0x14, 0xe4, 0x13, 0x3b,
	0xb6, 0xee, 0xba, 0x94, 0xe3, 0x19, 0x80, 0x78, 0x97, 0x6d, 0x62, 0x9e, 0xa4, 0xe7, 0xb2, 0xdf,
	0x1c, 0x1a, 0xfb, 0x9d, 0x83, 0xef, 0xee, 0xa5, 0x2b, 0x89, 0x69, 0x12, 0x35, 0x4a, 0xd3, 0x73,
	0x49, 0xd2, 0x6c, 0x73, 0xc3, 0xda, 0x62, 0x97, 0x0f, 0x7e, 0x80, 0xde, 0xdd, 0x26, 0x46, 0x60,
	0xfc, 0x22, 0x6e, 0x0a, 0xc5, 0x55, 0x88, 0x9f, 0x40, 0xfd, 0x3a, 0x5e, 0x5d, 0x89, 0x42, 0xe8,
	0x3c, 0x79, 0x55, 0xfd, 0xbe, 0x32, 0x69, 0x42, 0x5d, 0x3f, 0xdf, 0xe8, 0x6f, 0x03, 0x5a, 0x3b,
	0x25, 0xf0, 0x14, 0x6a, 0xd9, 0xcd, 0x5a, 0x68, 0x8a, 0xde, 0xc1, 0xc1, 0x83, 0xe4, 0xbb, 0x0d,
	0xa2, 0x9b, 0xb5, 0x60, 0x7a, 0x1e, 0x63, 0xa8, 0x5d, 0xc8, 0xf9, 0xb6, 0x5f, 0x1d, 0x1a, 0xfb,
	0x6d, 0xa6, 0xe3, 0xd1, 0xef, 0x06, 0x74, 0xcb, 0x50, 0xfc, 0x02, 0x06, 0x47, 0xfe, 0x84, 0x93,
	0x19, 0xf1, 0x22, 0x1e, 0xbd, 0x0d, 0x08, 0x3f, 0xf5, 0xc2, 0x80, 0xd8, 0x74, 0x4a, 0x89, 0x83,
	0x1e, 0xe1, 0x1e, 0x00, 0x75, 0x03, 0x46, 0xc2, 0x90, 0xfa, 0x1e, 0xaa, 0xe0, 0x16, 0xd4, 0x66,
	0x94, 0xfc, 0x84, 0xaa, 0xf8, 0x31, 0xec, 0xa9, 0x88, 0x33, 0xe2, 0x50, 0x46, 0xec, 0x08, 0x19,
	0xf8, 0x29, 0x3c, 0xb6, 0x82, 0xe0, 0x84, 0xda, 0x56, 0x44, 0x7d, 0x8f, 0x87, 0x91, 0xc5, 0x22,
	0x54, 0xc3, 0x1f, 0x03, 0x2e, 0x97, 0xa7, 0xd4, 0xa3, 0xe1, 0x21, 0xaa, 0xe3, 0x21, 0x3c, 0x2b,
	0xd7, 0x7f, 0x3c, 0xa5, 0xf6, 0x31, 0x0f, 0x4f, 0x27, 0x2e, 0xcd, 0xb7, 0x35, 0x70, 0x1f, 0x9e,
	0x94, 0x11, 0xb7, 0xab, 0x9a, 0xf8, 0x33, 0x78, 0xfe, 0x9f, 0x55, 0x7c, 0xca, 0x7c, 0x97, 0x87,
	0xc4, 0x62, 0xf6, 0x21, 0x6a, 0xe1, 0xcf, 0x61, 0xf8, 0xbe, 0xe1, 0x3b, 0xa8, 0xb6, 0x12, 0xa0,
	0x8c, 0xb2, 0x7d, 0x37, 0xb0, 0xbc, 0xb7, 0xf9, 0x19, 0x11, 0x02, 0xdc, 0x85, 0xd6, 0xc4, 0xf7,
	0x8f, 0x5d, 0x8b, 0x1d, 0xa3, 0x0e, 0x46, 0xd0, 0xf5, 0xfc, 0x88, 0x4e, 0x0b, 0x38, 0xea, 0xe2,
	0x36, 0xd4, 0x0f, 0x29, 0x23, 0x0e, 0xda, 0xc3, 0x1d, 0x68, 0x86, 0x4a, 0x46, 0x7b, 0x86, 0x7a,
	0x4a, 0x0b, 0xea, 0x45, 0x84, 0x69, 0x8d, 0xde, 0x30, 0xcb, 0x8b, 0x88, 0x83, 0x3e, 0xc2, 0x18,
	0x7a, 0x9e, 0x1f, 0x71, 0xdd, 0x22, 0xa1, 0xaa, 0xa1, 0xd1, 0x6f, 0x06, 0x74, 0xcb, 0xee, 0xc5,
	0xde, 0x1d, 0x07, 0xbc, 0x7a, 0xb0, 0xed, 0xef, 0x24, 0x25, 0x27, 0x0c, 0xa0, 0x55, 0xbc, 0x0d,
	0x3b, 0x37, 0xdc, 0xe6, 0xf8, 0x29, 0x34, 0xd4, 0x1b, 0x9b, 0x2c, 0xfa, 0x46, 0x6e, 0xcf, 0x0b,
	0x39, 0xa7, 0x8b, 0xd1, 0x5f, 0x15, 0x40, 0xff, 0x66, 0xc3, 0x23, 0x78, 0x11, 0x30, 0x7f, 0x4a,
	0x4f, 0xc8, 0x87, 0x18, 0xa6, 0xac, 0xa4, 0xa1, 0xec, 0x63, 0xfb, 0xae, 0xab, 0x58, 0x2c, 0xc7,
	0x21, 0x0e, 0xaa, 0xa9, 0x51, 0xe2, 0x5a, 0xf4, 0x84, 0x2b, 0x15, 0x51, 0x5d, 0x41, 0x18, 0x09,
	0x4f, 0x5d, 0xc2, 0x15, 0x03, 0x71, 0x50, 0x43, 0x41, 0x2c, 0xc7, 0xe1, 0x91, 0xcf, 0x8f, 0xfc,
	0x09, 0x6a, 0x2a, 0x0b, 0x05, 0x7e, 0x48, 0x23, 0x3a, 0x23, 0x9c, 0x11, 0xcb, 0xd6, 0xbf, 0x61,
	0xe4, 0xf3, 0xe2, 0x4c, 0xd4, 0x52, 0x08, 0x8f, 0xbc, 0xb1, 0xfe, 0x17, 0xd1, 0xc6, 0x00, 0x8d,
	0xd0, 0x66, 0x84, 0x78, 0x08, 0x26, 0xef, 0xe0, 0xe5, 0x99, 0xbc, 0xbc, 0x4f, 0xf0, 0x09, 0x68,
	0x3d, 0x02, 0xf5, 0x1d, 0x0c, 0x2a, 0x3f, 0x5b, 0x05, 0x74, 0x29, 0x57, 0x71, 0xba, 0x34, 0xe5,
	0x66, 0x39, 0x5e, 0x8a, 0x54, 0x7f, 0x25, 0xc7, 0x79, 0x2b, 0x5e, 0x27, 0xdb, 0xf7, 0xfe, 0x37,
	0xbc, 0xce, 0xd3, 0x3f, 0xaa, 0x86, 0x1d, 0x85, 0xf3, 0x86, 0x9e, 0xf9, 0xe6, 0x9f, 0x00, 0x00,
	0x00, 0xff, 0xff, 0x0a, 0x67, 0xd0, 0x69, 0x4e, 0x06, 0x00, 0x00,
}