text:
This library helps creating window applications where the windows can both stick to
screen borders and to each other.

The code originates from the Codeproject article
[Sticky Windows - How to make your (top-level) forms to stick one to the other or to the screen](https://www.codeproject.com/Articles/6045/Sticky-Windows-How-to-make-your-top-level-forms-to)
by Corneliu Tusnea. He never published a NuGet package, so I asked for his permission
to both create a repository at GiutHub and publish it as a NuGet package.

## Build status and NuGet packages

|                   | Stable                                                         | Pre-release                                              |
|-------------------|----------------------------------------------------------------|----------------------------------------------------------|
| AppVeyor          | [![Build status][appveyor-master-badge]][appveyor-master-link] | [![Build status][appveyor-dev-badge]][appveyor-dev-link] |
| StickyWindows     | [![NuGet][nuget-master-badge]][nuget-master-link]              | [![NuGet][nuget-dev-badge]][nuget-dev-link]              |
| StickyWindows.Wpf | [![NuGet][nuget-master-wpf-badge]][nuget-master-wpf-link]      | [![NuGet][nuget-dev-wpf-badge]][nuget-dev-wpf-link]      |

[appveyor-master-badge]: https://ci.appveyor.com/api/projects/status/ynjy63xrlvrrmseg/branch/master?svg=true
[appveyor-master-link]:  https://ci.appveyor.com/project/thoemmi/stickywindows/branch/master
[appveyor-dev-badge]:    https://ci.appveyor.com/api/projects/status/ynjy63xrlvrrmseg/branch/develop?svg=true
[appveyor-dev-link]:     https://ci.appveyor.com/project/thoemmi/stickywindows/branch/develop
[nuget-master-badge]:    https://img.shields.io/nuget/v/StickyWindows.svg
[nuget-master-link]:     https://www.nuget.org/packages/StickyWindows
[nuget-dev-badge]:       https://img.shields.io/nuget/vpre/StickyWindows.svg
[nuget-dev-link]:        https://www.nuget.org/packages/StickyWindows
[nuget-master-wpf-badge]:  https://img.shields.io/nuget/v/StickyWindows.WPF.svg
[nuget-master-wpf-link]:   https://www.nuget.org/packages/StickyWindows.WPF
[nuget-dev-wpf-badge]:     https://img.shields.io/nuget/vpre/StickyWindows.WPF.svg
[nuget-dev-wpf-link]:      https://www.nuget.org/packages/StickyWindows.WPF

## Usage

Actually there are two libraries published: one is for WinForms applications,
and the other one for WPF applications. The latter bases on the WinForms package
though. but this shouldn't be an issue as that the WinForms library is part of the
.NET framework and as such is always available.

### WinForms

For WinForms application, use the
[**StickyWindow**](https://www.nuget.org/packages/StickyWindows)
package.

In the **constructor** of your form add this line:

```csharp
new StickyWindows.StickyWindow(this);
```

If you want to deviate from the default settings, `StickyWindow` provides following
boolean properties (which are all `true` by default:

* `StickOnMove`
Allows the form to try to stick when the form is moved.
* `StickOnResize`
Allows the form to try to stick when the form is resized.
* `StickToOther`
Allows the form to try to stick to other stick-able forms.
* `StickToScreen`
Allows the form to try to stick to the screen margins.

### WPF

For WinForms application, use the
[**StickyWindow.WPF**](https://www.nuget.org/packages/StickyWindows.WPF)
package.

You have two options to make your windows "sticky":

1. Subscribe to your window's `Loaded` event and call the extension method
   `CreateStickyWindow` in the handler:
   ```csharp
   _stickyWindow = this.CreateStickyWindow();
   ```

2. Use the `StickyWindowBehavior` in your XAML code (which I think is more elegant
   than option 1):
   ```xml
    <Window
      x:Class="WpfTest.Window2"
      xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
      xmlns:wpf="clr-namespace:StickyWindows.WPF;assembly=StickyWindows.WPF"
      ...>
      <i:Interaction.Behaviors>
        <wpf:StickyWindowBehavior />
      </i:Interaction.Behaviors>
      ...
    </Window>
   ```

Both options support the same properties as the WinForms implementation.

> Please note that **StickyWindows.WPF** requires **System.Windows.Interactivity**,
> which is neither part of the library nor a dependency of the NuGet package. The point
> is, there's no official NuGet package for **System.Windows.Interactivity** by Microsoft.
> I decided against delivering this library as part of **StickyWindows.WPF** as it may
> conflict with different versions in other libraries you may be using potentially.

## Version History

### v0.3 (not released yet)

* Fixed the MaximumSize and MinimumSize issue reported in #5 (Thanks to @lucky3)
* Added [SourceLink](https://github.com/dotnet/sourcelink) support

### v0.2 (11-Apr-2017)

* Fixed strange margin when running on Windows 10 ([#1](https://github.com/thoemmi/StickyWindows/issues/1))

### v0.1 (10-Mar-2017)

* Inital Release


text:
================================================================================
ResourcePoolResourceUsage
================================================================================

.. describe:: Property of

    :py:class:`~pyvisdk.do.resource_pool_runtime_info.ResourcePoolRuntimeInfo`

.. describe:: Extends

    :py:class:`~pyvisdk.mo.dynamic_data.DynamicData`

.. class:: pyvisdk.do.resource_pool_resource_usage.ResourcePoolResourceUsage

    .. py:attribute:: maxUsage

        Current upper-bound on usage. The upper-bound is based on the limit configured on this resource pool, as well as limits configured on any parent resource pool.

    .. py:attribute:: overallUsage

        Close to real-time resource usage of all running child virtual machines, including virtual machines in child resource pools.

    .. py:attribute:: reservationUsed

        Total amount of resources that have been used to satisfy the reservation requirements of all descendants of this resource pool (includes both resource pools and virtual machines).

    .. py:attribute:: reservationUsedForVm

        Total amount of resources that have been used to satisfy the reservation requirements of running virtual machines in this resource pool or any of its child resource pools.

    .. py:attribute:: unreservedForPool

        Total amount of resources available to satisfy a reservation for a child resource pool. In the undercommitted state, this is limited by the capacity at the root node. In the overcommitted case, this could be higher since we do not perform the dynamic capacity checks.

    .. py:attribute:: unreservedForVm

        Total amount of resources available to satisfy a reservation for a child virtual machine. In general, this should be the same as unreservedForPool. However, in the overcommitted case, this is limited by the remaining available resources at the root node.

redpajama_set_name: RedPajamaGithub


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.imos.pi.common;

import lombok.Getter;
import lombok.Setter;

/**
 *
 * @author Alok
 */
@Setter @Getter
public class MailProperty {

    private String mailSmtpHost, mailSmtpSslTrust, mailSmtpUser, mailSmtpPort,
            mailSmtpAuth, to, from, subject, message;

    private boolean mailSmtpStarttlsEnable;
}


text:
MyColorPalettes
===============

A simple tool for saving and managing your color palettes. Under the hood this is a simple AngularJS app, but no knowledge of Angular is required - just some basic work with JSON.

To manage your palettes open the file js/controllers.js.

The structure of each block is fairly simple:

```
{
	"title": "NAME OF THE PALETTE",
	"data": [
		{
			"name": "OPTIONAL OOLOR NAME - shows up in the tooltip",
			"code": "#HEXVALUE"
		},
		{
			"name": "ADD AS MANY COLORS AS YOU WANT",
			"code": "#HEXVALUE"
		}
	],
	"tags": [
		"as many tags",
		"as you want"
	]
}
```

You can see an example page on http://fourtonfish.com/my-color-palettes/. You can search through your collection by palette name, tags and the optional color names. On the page above, try  to search for _favorite_, _bright_ or _jet black_.

UPDATE
======

![My Color Palette.app](/app-scr/app-beta.png)

I am already working on an app, you can preview it at [fourtonfish.com/my-color-palettes/app](http://fourtonfish.com/my-color-palettes/app/)


text:
layout: relation
title: 'list'
shortdef: 'list'
udver: '2'
---

The `list` relation is used for chains of comparable items. It is not currently attested in the Swedish treebank.

Web text often contains passages which are meant to be interpreted as lists but are parsed as single sentences. Email signatures in particular contain these structures, in the form of contact information: the different contact information items are labeled as `list`; the key-value pair relations are labeled as [appos]().

In lists with more than two items, all items of the list shoud modify the first one.

~~~ sdparse
Steve Jones Mobil: 555-9814 Mejl: jones@abc.edf
flat:name(Steve-1, Jones-2)
list(Steve-1, Mobil:-3)
list(Steve-1, Mejl:-5)
appos(Mobil:-3, 555-9814-4)
appos(Mejl:-5, jones@abc.edf-6)
~~~
<!-- Interlanguage links updated Po lis 14 15:35:29 CET 2022 -->


text:
package de.uni_hildesheim.sse.wildcat.plugins;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Map;
import java.util.TimeZone;

import de.uni_hildesheim.sse.monitoring.runtime.configuration.Configuration;
import de.uni_hildesheim.sse.monitoring.runtime.plugins.IPluginParameter;
import de.uni_hildesheim.sse.monitoring.runtime.plugins.Plugin;
import de.uni_hildesheim.sse.monitoring.runtime.plugins.PluginRegistry;
import de.uni_hildesheim.sse.wildcat.gui.WildCATContextTreeWindow;
import de.uni_hildesheim.sse.wildcat.launcher.GearsBridgeLauncher;
import de.uni_hildesheim.sse.wildcat.listeners.
    WildCATMonitoringGroupCreationListener;
import de.uni_hildesheim.sse.wildcat.listeners.WildCATTimerChangeListener;
import de.uni_hildesheim.sse.wildcat.listeners.WildCATValueChangeListener;
import de.uni_hildesheim.sse.wildcat.services.WConfiguration;
import de.uni_hildesheim.sse.wildcat.services.WServiceRegistry;

/**
 * WildCAT Plugin for SPASS-monitor.
 *
 * @author Stephan Dederichs
 *
 * @since 1.00
 * @version 1.00
 */
public class WildCATPlugin implements Plugin {

    /**
     * Stores The {@link GearsBridgeLauncher}.
     *
     * @since 1.00
     */
    public static final GearsBridgeLauncher GEARSBRIDGELAUNCHER = new
            GearsBridgeLauncher();

    /**
     * WildCAT context GUI.
     *
     * @since 1.00
     */
    private WildCATContextTreeWindow wnd;

    /**
     * Public default constructor.
     *
     * @since 1.00
     */
    public WildCATPlugin() {
    }

    @Override
    public void start(IPluginParameter args) {
        String path = null;
        // Checking args
        if (null != args) {
            // getting path for configuration file from parameter
            path = args.get("wildcatConfig");
        }
        // if no path specified -> default configuration
        if (null == path) {
            Configuration.LOG.info("Configuration file not specified, "
                + "loading default configuration.");
            path = "../InstrumentationWildCAT/src/de/uni_hildesheim"
                    + "/sse/wildcat/configuration/config.xml";
        }

        // Reading configuration
        GEARSBRIDGELAUNCHER.readConfiguration(path, Configuration.LOG);
        // attach listeners
        WildCATMonitoringGroupCreationListener mgListener = new
                WildCATMonitoringGroupCreationListener();
        PluginRegistry.attachMonitoringGroupCreationListener(mgListener);
        PluginRegistry.attachMonitoringGroupBurstChangeListener(mgListener);
        PluginRegistry.attachTimerChangeListener(new
                WildCATTimerChangeListener());
        PluginRegistry.attachValueChangeListener(new
                WildCATValueChangeListener());
        // Initial creatin of required resources
        WServiceRegistry.createSpassMonitorResource(
                InstrumentationContextConstants.SPASS_MONITOR_DOMAIN);
        // Registering the configurationService
        WServiceRegistry.registerService("Configuration", new WConfiguration());

        // open GUI only if explicitly specified in parameters
        // parameters == null --> no GUI
        if (null != args) {
            // checking if parameter "wildcatGUI" is available an open the
            // GUI if available
            String gui = args.get("wildcatGUI");
            if (null != gui) {
                openGUI();
            }
        }
    }

    @Override
    public void stop() {
    }

    /**
     * Opens the WildCAT Context Tree Window.
     *
     * @since 1.00
     */
    private void openGUI() {
        wnd = new WildCATContextTreeWindow(
                GEARSBRIDGELAUNCHER.getContext());
        wnd.open();
    }

    /**
     * Utility Method for continuous running the application.
     *
     * @since 1.00
     */
    @SuppressWarnings("static-access")
    public void proceed() {
        // Continuous runnning this loop
        while (true) {
            try {
                // sending a notification to all listeners
                GEARSBRIDGELAUNCHER.sendUpdateNotification(this, null);
                // Updating gui
                wnd.updateGUI();
                // Wait two seconds
                Thread.currentThread().sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Main method for testing.
     *
     * @param args program parameter.
     */
    public static void main(String[] args) {
        // create plugin
        Plugin plugIn = new WildCATPlugin();
        // Debug-Out
        Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT+1:00"));
        SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
        System.out.println("Info\t" + sdf.format(cal.getTime())
                + " - WildCATPlugin is running...");
        // starting plugin
        final Map<String, String> params = new HashMap<String, String>();
        params.put("wildcatConfig",
                "../InstrumentationWildCAT/src/de/uni_hildesheim"
                        + "/sse/wildcat/configuration/config.xml");
        params.put("wildcatGUI", "true");
        plugIn.start(new IPluginParameter() {
            @Override
            public String get(String key) {
                return params.get(key);
            }
        });

        // doing something
        ((WildCATPlugin) plugIn).proceed();
    }

}


text:
package org.apache.beam.sdk.io.gcp.spanner;

import com.google.cloud.spanner.BatchReadOnlyTransaction;
import org.apache.beam.sdk.transforms.DoFn;

/** Creates a batch transaction. */
class CreateTransactionFn extends DoFn<Object, Transaction> {

  private final SpannerIO.CreateTransaction config;

  CreateTransactionFn(SpannerIO.CreateTransaction config) {
    this.config = config;
  }

  private transient SpannerAccessor spannerAccessor;

  @DoFn.Setup public void setup() throws Exception {
    spannerAccessor = config.getSpannerConfig().connectToSpanner();
  }

  @Teardown public void teardown() throws Exception {
    spannerAccessor.close();
  }

  @ProcessElement public void processElement(ProcessContext c) throws Exception {
    BatchReadOnlyTransaction tx = spannerAccessor.getBatchClient()
        .batchReadOnlyTransaction(config.getTimestampBound());
    c.output(Transaction.create(tx.getBatchTransactionId()));
  }

}


text:
package liverpc

import (
	"go-common/app/service/live/captcha/api/liverpc/v0"
	"go-common/app/service/live/captcha/api/liverpc/v1"
	"go-common/library/net/rpc/liverpc"
)

// Client that represents a liverpc captcha service api
type Client struct {
	cli *liverpc.Client
	// V0Captcha presents the controller in liverpc
	V0Captcha v0.CaptchaRPCClient
	// V1Captcha presents the controller in liverpc
	V1Captcha v1.CaptchaRPCClient
}

// DiscoveryAppId the discovery id is not the tree name
var DiscoveryAppId = "live.captcha"

// New a Client that represents a liverpc live.captcha service api
// conf can be empty, and it will use discovery to find service by default
// conf.AppID will be overwrite by a fixed value DiscoveryAppId
// therefore is no need to set
func New(conf *liverpc.ClientConfig) *Client {
	if conf == nil {
		conf = &liverpc.ClientConfig{}
	}
	conf.AppID = DiscoveryAppId
	var realCli = liverpc.NewClient(conf)
	cli := &Client{cli: realCli}
	cli.clientInit(realCli)
	return cli
}

func (cli *Client) GetRawCli() *liverpc.Client {
	return cli.cli
}

func (cli *Client) clientInit(realCli *liverpc.Client) {
	cli.V0Captcha = v0.NewCaptchaRPCClient(realCli)
	cli.V1Captcha = v1.NewCaptchaRPCClient(realCli)
}


text:
var React = require('react');
var Input = require('./base_text_input');
var ErrorList = require('./base_error_list');

module.exports = React.createClass({
    decimalPlacesToSteps: function () {
        var decimalPlaces = this.props.field.decimal_places,
            i, result, decArray = [];

        if (decimalPlaces === null) {
            return "0.01";
        }

        if (decimalPlaces > 0) {
            for (i = 0; i < decimalPlaces; i += 1) {
                decArray.push("0");
            }
            decArray.splice(1, 0, ".");
        }
        decArray.push("1");
        result = decArray.join("");
        return result;
    },

    render: function () {
        var step = this.decimalPlacesToSteps();
        return (

                {this.props.field.label}
                <Input type="number" step={step} field={this.props.field} />

{this.props.field.help_text}

                <ErrorList errors={this.props.errors} />

        )
    }
});


text:
/***********************************************************************
 * Generated by Hottentot CC Generator
 * Date: 01-02-2016 01:45:06
 * Name: echo_service_request_handler.h
 * Description:
 *   This file contains definition of service's request handler class.
 ***********************************************************************/

#ifndef _IR_NTNAEEM_HOTTENTOT_EXAMPLES_WIN32_ECHO__SERVICE__ECHO_SERVICE_REQUEST_HANDLER_H_
#define _IR_NTNAEEM_HOTTENTOT_EXAMPLES_WIN32_ECHO__SERVICE__ECHO_SERVICE_REQUEST_HANDLER_H_

#ifdef _MSC_VER
typedef __int8 int8_t;
typedef unsigned __int8 uint8_t;
typedef __int16 int16_t;
typedef unsigned __int16 uint16_t;
typedef __int32 int32_t;
typedef unsigned __int32 uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;
#else
#include <stdint.h>
#endif

#include <string>

#include <naeem/hottentot/runtime/service/request_handler.h>

namespace ir {
namespace ntnaeem {
namespace hottentot {
namespace examples {
namespace win32 {
namespace echo {
namespace service {
  class EchoServiceRequestHandler : public ::naeem::hottentot::runtime::service::RequestHandler {
  public:
    EchoServiceRequestHandler(::naeem::hottentot::runtime::service::Service *service)
      : ::naeem::hottentot::runtime::service::RequestHandler(service) {
    }
    virtual ~EchoServiceRequestHandler() {}
  public:
    virtual void HandleRequest(::naeem::hottentot::runtime::Request &   /* Request object */, ::naeem::hottentot::runtime::Response &  /* Response object */);
  };
} // END OF NAMESPACE service
} // END OF NAMESPACE echo
} // END OF NAMESPACE win32
} // END OF NAMESPACE examples
} // END OF NAMESPACE hottentot
} // END OF NAMESPACE ntnaeem
} // END OF NAMESPACE ir

#endif


text:
package poussecafe.attribute.list;

import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import poussecafe.attribute.AutoAdapter;
import poussecafe.attribute.ListAttribute;
import poussecafe.attribute.adapters.AutoAdaptingDataAdapter;
import poussecafe.attribute.adapters.DataAdapter;

import static java.util.Objects.requireNonNull;

public class ListAttributeBuilder<T> {

    public ListAttributeBuilder(Class<T> elementClass) {
        requireNonNull(elementClass);
        this.elementClass = elementClass;
    }

    private Class<T> elementClass;

    public Complete<T> withList(List<T> list) {
        Objects.requireNonNull(list);
        return new NoAdaptingListAttributeBuilder<>(list);
    }

    public static interface Complete<T> {

        ListAttribute<T> build();
    }

    public <U> ExpectingReadAdapters<U, T> itemsStoredAs(Class<U> storedElementType) {
        requireNonNull(storedElementType);
        return new FunctionAdapterBasedListAttributeBuilder<>();
    }

    public static interface ExpectingReadAdapters<U, T> {

        ExpectingWriteAdapters<U, T> adaptOnGet(Function<U, T> adapter);
    }

    public static interface ExpectingWriteAdapters<U, T> {

        ExpectingList<U, T> adaptOnSet(Function<T, U> adapter);
    }

    public static interface ExpectingList<U, T> {

        Complete<T> withList(List<U> storageList);
    }

    public <U extends AutoAdapter<T>> ExpectingList<U, T> usingItemAutoAdapter(Class<U> dataAdapterClass) {
        return usingItemDataAdapter(new AutoAdaptingDataAdapter<>(elementClass, dataAdapterClass));
    }

    public <U> ExpectingList<U, T> usingItemDataAdapter(DataAdapter<U, T> dataAdapter) {
        Objects.requireNonNull(dataAdapter);
        DataAdapterBasedListAttributeBuilder<U, T> builder = new DataAdapterBasedListAttributeBuilder<>();
        builder.adapter = dataAdapter;
        return builder;
    }
}


text:
#pragma once

#include <SFML/Audio/Sound.hpp>
#include <SFML/Graphics/Sprite.hpp>

#include "Interface/container.hpp"
#include "States/state.hpp"

class MenuState final : public State
{
    private:
        sf::Sprite     _backgroundSprite;
        GUI::Container _guiContainer;
        sf::Sound      _sound;

    public:
             MenuState(StateStack& stack, Context context);

        void draw() override;
        bool update(const sf::Time dt) noexcept override;
        bool handleEvent(const sf::Event& event) override;
};


text:
<?php

namespace Cougar\UnitTests\RestService;

use Cougar\Security\Security;
use Cougar\RestService\AnnotatedRestService;
use Cougar\Util\Xml;

/**
 * Generated by PHPUnit_SkeletonGenerator 1.2.0 on 2013-03-18 at 12:50:03.
 */
class AnnotatedRestServiceTestDelete extends \PHPUnit_Framework_TestCase {

    /**
     * @var AnnotatedRestService
     */
    protected $object;

    public static function setUpBeforeClass()
    {
        require_once(__DIR__ . "/../../cougar.php");
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSimpleCase() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize($object->simpleCase()));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSingleUriArgument() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/SingleUriArgument/uri1";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->singleUriArgument("uri1")));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testMultiUriArgument() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/MultiUriArgument/uri1/uri2/uri3";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->multiUriArgument("uri1", "uri2", "uri3")));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testMultiUriArgumentPlus() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/MultiUriArgument/plus/uri1/uri2/uri3";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->multiUriArgumentPlus(array("uri1", "uri2", "uri3"))));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testMultiUriArgumentWithLiteral() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/MultiUriArgument/uri1/literal/uri2";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->multiUriArgumentWithLiteral("uri1", "uri2")));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testEmptyResponse() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/EmptyResponse";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString("");

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testGetValueOneArgumentSpaceAtEnd()
    {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/Space/At/End";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["something"] = "foo";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentSpaceAtEnd("foo")));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSingleGetArgumentFloat() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/float";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["float"] = "3.5";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentFloat(3.5)));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSingleGetArgumentString() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/string";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["string"] = "three";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentString('three')));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSingleGetArgumentInt() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/int";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["int"] = "3";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentInt(3)));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testSingleGetArgumentBool() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/bool";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["bool"] = "true";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentBool(true)));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testGetValueOneGetArgumentOnePostArgument()
    {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/GetValue/OneArg/Space/At/End";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        $_GET["something"] = "foo";
        $_POST["somethingelse"] = "bar";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize(
            $object->getValueOneArgumentSpaceAtEnd("foo")));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     * @expectedException \Cougar\Exceptions\MethodNotAllowedException
     */
    public function testDeleteWithGet() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "GET";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
        $this->fail("Expected exception was not thrown");
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     * @expectedException \Cougar\Exceptions\BadRequestException
     */
    public function testNonExistantEndPoint() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/whatever";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
        $this->fail("Expected exception was not thrown");
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testDeleteBody() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/with/body";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";
        global $_BODY;
        $_BODY = "Sample Body";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(serialize($object->DeleteBody($_BODY)));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     * @expectedException \Cougar\Exceptions\BadRequestException
     */
    public function testOptionsWithDelete() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "OPTIONS";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/vnd.php.serialized";

        $object = new AnnotatedRestServiceDeleteTests();
        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
        $this->fail("Expected exception was not thrown");
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testJson() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/json";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(json_encode($object->simpleCase()));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testXML() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/xml";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(Xml::toXml($object->simpleCase())->asXML());

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     */
    public function testHTML() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/SimpleCase";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "text/html";

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(Xml::toXml($object->simpleCase())->asXML());

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     *
     * @todo FIX ME
     */
    public function testJsonContentType() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/ContentType";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/json";
        $_SERVER["HTTP_CONTENT_TYPE"] = "application/json";

        $object = new \stdClass();
        $object->foo = "bar";
        $json_object = json_encode($object);

        global $_BODY;
        $_BODY = $json_object;

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(json_encode(
                $object->PostBodyJson($json_object)));

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }

    /**
     * @covers \Cougar\RestService\AnnotatedRestService::bindFromObject
     * @covers \Cougar\RestService\AnnotatedRestService::handleRequest
     *
     * @todo FIX ME
     */
    public function testXmlContentType() {
        $_SERVER["SERVER_PROTOCOL"] = "HTTP/1.1";
        $_SERVER["REQUEST_METHOD"] = "DELETE";
        $_SERVER["REQUEST_URI"] = "/delete/ContentType";
        $_SERVER["PHP_SELF"] = "/request_handler";
        $_SERVER["HTTP_HOST"] = "localhost";
        $_SERVER["HTTP_ACCEPT"] = "application/xml";
        $_SERVER["HTTP_CONTENT_TYPE"] = "application/xml";

        $xml = new \SimpleXMLElement("<foo><bar id=\"1\"/></foo>");
        $xml_text = trim($xml->asXML());

        global $_BODY;
        $_BODY = $xml_text;

        $object = new AnnotatedRestServiceDeleteTests();
        $this->expectOutputString(
            XML::toXml($object->PostBodyXml($xml_text))->asXML());

        $service = new AnnotatedRestService(new Security());
        $service->bindFromObject($object);
        $service->handleRequest();
    }
}

class AnnotatedRestServiceDeleteTests
{
    /**
     * @Path /delete/SimpleCase
     * @Methods DELETE
     */
    public function simpleCase()
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/SingleUriArgument/:argument
     */
    public function singleUriArgument($argument)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/MultiUriArgument/:argument1/:argument2:/:argument3
     */
    public function multiUriArgument($argument1, $argument2, $argument3)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/MultiUriArgument/plus/:arguments+
     */
    public function multiUriArgumentPlus(array $arguments)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/MultiUriArgument/:argument1/literal/:argument2
     */
    public function multiUriArgumentWithLiteral($argument1, $argument2)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/EmptyResponse
     */
    public function emptyResponse()
    {
        # Don't return anything; response should be blank
    }

    /**
     * @Path /delete/GetValue/OneArg/Space/At/End
     * @GetValue something
     */
    public function getValueOneArgumentSpaceAtEnd($something)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/GetValue/OneArg/float
     * @GetValue float float
     */
    public function getValueOneArgumentFloat($float)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/GetValue/OneArg/string
     * @GetValue string string
     */
    public function getValueOneArgumentString($string)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/GetValue/OneArg/int
     * @GetValue int int
     */
    public function getValueOneArgumentInt($int)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/GetValue/OneArg/bool
     * @GetValue bool bool
     */
    public function getValueOneArgumentBool($bool)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/GetValue/OneArg/Space/At/End
     * @GetValue something
     * @PostValue somethingelse
     */
    public function getValueOneGetArgumentOnePostArgument($something, $somethingelse)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/with/body
     * @Methods DELETE
     * @Body body
     */
    public function deleteBody($body)
    {
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/ContentType
     * @Methods DELETE
     * @Body body
     * @Accepts JSON
     */
    public function postBodyJson($body)
    {
        $json = json_decode($body);
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }

    /**
     * @Path /delete/ContentType
     * @Methods DELETE
     * @Body body
     * @Accepts XML
     */
    public function postBodyXml($body)
    {
        $xml = new \SimpleXMLElement($body);
        return array("method" => __FUNCTION__,
            "arguments" => func_get_args());
    }
}


text:
import React, { useCallback } from 'react';
import { observer, inject } from 'mobx-react';
import type { AssetToken } from '../../api/assets/types';
import AssetSettingsDialog from '../../components/assets/AssetSettingsDialog';
import WalletTokens from '../../components/wallet/tokens/wallet-tokens/WalletTokens';
import type { InjectedProps } from '../../types/injectedPropsType';
import { getAssetTokens } from '../../utils/assets';

type Props = InjectedProps;
type OpenAssetSettingsDialogArgs = {
  asset: AssetToken;
};
const WalletTokensPage = inject(
  'stores',
  'actions'
)(
  observer((props: Props) => {
    const { actions, stores } = props;
    const { assets, profile, wallets, app } = stores;
    const {
      all,
      favorites,
      insertingAssetUniqueId,
      removingAssetUniqueId,
    } = assets;
    const {
      setEditedAsset,
      onOpenAssetSend,
      onToggleFavorite,
    } = actions.assets;
    const { open } = actions.dialogs;
    const { active: activeWallet } = wallets;
    const { currentLocale } = profile;
    const openAssetSettingsDialog = useCallback(
      ({ asset }: OpenAssetSettingsDialogArgs) => {
        setEditedAsset.trigger({
          asset,
        });
        open.trigger({
          dialog: AssetSettingsDialog,
        });
      },
      [open, setEditedAsset]
    );
    // Guard against potential null values
    if (!activeWallet)
      throw new Error('Active wallet required for WalletSummaryPage.');
    const walletTokens = activeWallet.assets.total;
    const assetTokens = getAssetTokens(all, walletTokens);
    const totalRawAssets = activeWallet.assets.total.length;
    const totalAssets = assetTokens.length;
    const hasRawAssets = activeWallet.assets.total.length > 0;
    const isLoadingAssets = hasRawAssets && totalAssets < totalRawAssets;
    return (
      <WalletTokens
        assets={assetTokens}
        currentLocale={currentLocale}
        insertingAssetUniqueId={insertingAssetUniqueId}
        isLoadingAssets={isLoadingAssets}
        onAssetSettings={openAssetSettingsDialog}
        onCopyAssetParam={() => {}}
        onOpenAssetSend={onOpenAssetSend.trigger}
        onToggleFavorite={onToggleFavorite.trigger}
        removingAssetUniqueId={removingAssetUniqueId}
        onExternalLinkClick={app.openExternalLink}
        tokenFavorites={favorites}
        wallet={activeWallet}
      />
    );
  })
);
export default WalletTokensPage;


text:
!******************************************************************************
!******************************************************************************
!
!   This module serves as the F2PY interface to the core functions. All the
!   functions have counterparts as PYTHON implementations.
!
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_criterion(crit_val, x, is_interpolated_int, num_draws_emax_int, num_periods_int, num_points_interp_int, is_myopic_int, edu_start_int, is_debug_int, edu_max_int, min_idx_int, delta_int, data_est_int, num_agents_est_int, num_draws_prob_int, tau_int, periods_draws_emax_int, periods_draws_prob_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: crit_val

    DOUBLE PRECISION, INTENT(IN)    :: delta_int
    DOUBLE PRECISION, INTENT(IN)    :: x(26)

    INTEGER, INTENT(IN)             :: num_points_interp_int
    INTEGER, INTENT(IN)             :: num_agents_est_int
    INTEGER, INTENT(IN)             :: num_draws_emax_int
    INTEGER, INTENT(IN)             :: num_draws_prob_int
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: min_idx_int
    INTEGER, INTENT(IN)             :: edu_max_int

    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_emax_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_prob_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: data_est_int(:, :)
    DOUBLE PRECISION, INTENT(IN)    :: tau_int

    LOGICAL, INTENT(IN)             :: is_interpolated_int
    LOGICAL, INTENT(IN)             :: is_myopic_int
    LOGICAL, INTENT(IN)             :: is_debug_int

    !/* internal objects            */

    DOUBLE PRECISION                :: contribs(num_agents_est_int * num_periods_int)
    DOUBLE PRECISION                :: shocks_cholesky(4, 4)
    DOUBLE PRECISION                :: coeffs_home(1)
    DOUBLE PRECISION                :: coeffs_edu(3)
    DOUBLE PRECISION                :: coeffs_a(6)
    DOUBLE PRECISION                :: coeffs_b(6)

    INTEGER                         :: dist_optim_paras_info

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Assign global RESFORT variables
    max_states_period = SIZE(states_all, 2)

    ! Transfer global RESFORT variables
    num_points_interp = num_points_interp_int
    is_interpolated = is_interpolated_int
    num_agents_est = num_agents_est_int
    num_draws_emax = num_draws_emax_int
    num_draws_prob = num_draws_prob_int
    num_periods = num_periods_int
    data_est = data_est_int
    is_myopic = is_myopic_int
    edu_start = edu_start_int
    is_debug = is_debug_int
    min_idx = min_idx_int
    edu_max = edu_max_int
    delta = delta_int
    tau = tau_int

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF (ALLOCATED(mapping_state_idx)) DEALLOCATE(mapping_state_idx)
    IF (ALLOCATED(periods_payoffs_systematic)) DEALLOCATE(periods_payoffs_systematic)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)
    IF (ALLOCATED(periods_emax)) DEALLOCATE(periods_emax)
    IF (ALLOCATED(states_number_period)) DEALLOCATE(states_number_period)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)

    !# Distribute model parameters
    CALL dist_optim_paras(coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, x, dist_optim_paras_info)

    ! Solve requested model
    CALL fort_solve(periods_payoffs_systematic, states_number_period, mapping_state_idx, periods_emax, states_all, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, periods_draws_emax_int, delta, is_debug, is_interpolated, is_myopic, edu_start, edu_max)

    ! Evaluate criterion function for observed data
    CALL fort_contributions(contribs, periods_payoffs_systematic, mapping_state_idx, periods_emax, states_all, shocks_cholesky, data_est, periods_draws_prob_int, delta, tau, edu_start, edu_max)

    crit_val = get_log_likl(contribs, num_agents_est, num_periods)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_solve(periods_payoffs_systematic_int, states_number_period_int, mapping_state_idx_int, periods_emax_int, states_all_int, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, is_interpolated_int, num_draws_emax_int, num_periods_int, num_points_interp_int, is_myopic_int, edu_start_int, is_debug_int, edu_max_int, min_idx_int, delta_int, periods_draws_emax_int, max_states_period_int)

    ! The presence of max_states_period breaks the equality of interfaces. However, this is required so that the size of the return arguments is known from the beginning.

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    INTEGER, INTENT(OUT)            :: mapping_state_idx_int(num_periods_int, num_periods_int, num_periods_int, min_idx_int, 2)
    INTEGER, INTENT(OUT)            :: states_all_int(num_periods_int, max_states_period_int, 4)
    INTEGER, INTENT(OUT)            :: states_number_period_int(num_periods_int)

    DOUBLE PRECISION, INTENT(OUT)   :: periods_payoffs_systematic_int(num_periods_int, max_states_period_int, 4)
    DOUBLE PRECISION, INTENT(OUT)   :: periods_emax_int(num_periods_int, max_states_period_int)
    DOUBLE PRECISION, INTENT(IN)    :: delta_int

    INTEGER, INTENT(IN)             :: max_states_period_int
    INTEGER, INTENT(IN)             :: num_draws_emax_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: num_points_interp_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: min_idx_int

    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_emax_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: shocks_cholesky(4, 4)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_home(:)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_edu(:)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_a(:)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_b(:)

    LOGICAL, INTENT(IN)             :: is_interpolated_int
    LOGICAL, INTENT(IN)             :: is_myopic_int
    LOGICAL, INTENT(IN)             :: is_debug_int

!-----------------------------------------------------------------------------
! Algorithm
!-----------------------------------------------------------------------------

    !# Transfer global RESFORT variables
    max_states_period = max_states_period_int
    num_points_interp = num_points_interp_int
    is_interpolated = is_interpolated_int
    num_draws_emax = num_draws_emax_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    is_myopic = is_myopic_int
    is_debug = is_debug_int
    min_idx = min_idx_int
    edu_max = edu_max_int
    delta = delta_int

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF (ALLOCATED(mapping_state_idx)) DEALLOCATE(mapping_state_idx)
    IF (ALLOCATED(periods_payoffs_systematic)) DEALLOCATE(periods_payoffs_systematic)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)
    IF (ALLOCATED(periods_emax)) DEALLOCATE(periods_emax)
    IF (ALLOCATED(states_number_period)) DEALLOCATE(states_number_period)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)

    ! Call FORTRAN solution
    CALL fort_solve(periods_payoffs_systematic, states_number_period, mapping_state_idx, periods_emax, states_all, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, periods_draws_emax_int, delta, is_debug, is_interpolated, is_myopic, edu_start, edu_max)

    ! Assign to initial objects for return to PYTHON
    periods_payoffs_systematic_int = periods_payoffs_systematic
    states_number_period_int = states_number_period
    mapping_state_idx_int = mapping_state_idx
    periods_emax_int = periods_emax
    states_all_int = states_all

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_evaluate(contribs, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, is_interpolated_int, num_draws_emax_int, num_periods_int, num_points_interp_int, is_myopic_int, edu_start_int, is_debug_int, edu_max_int, min_idx_int, delta_int, data_est_int, num_agents_est_int, num_draws_prob_int, tau_int, periods_draws_emax_int, periods_draws_prob_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: contribs(num_agents_est_int * num_periods_int)

    INTEGER, INTENT(IN)             :: num_draws_prob_int
    INTEGER, INTENT(IN)             :: num_draws_emax_int
    INTEGER, INTENT(IN)             :: num_agents_est_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: num_points_interp_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: min_idx_int

    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_emax_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_prob_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: shocks_cholesky(4, 4)
    DOUBLE PRECISION, INTENT(IN)    :: data_est_int(:, :)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_home(:)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_edu(:)
    DOUBLE PRECISION, INTENT(IN)    :: delta_int

    DOUBLE PRECISION, INTENT(IN)    :: coeffs_a(:)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_b(:)
    DOUBLE PRECISION, INTENT(IN)    :: tau_int

    LOGICAL, INTENT(IN)             :: is_interpolated_int
    LOGICAL, INTENT(IN)             :: is_myopic_int
    LOGICAL, INTENT(IN)             :: is_debug_int

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Transfer global RESFORT variables
    num_points_interp = num_points_interp_int
    is_interpolated = is_interpolated_int
    num_agents_est = num_agents_est_int
    num_draws_prob = num_draws_prob_int
    num_draws_emax = num_draws_emax_int
    num_periods = num_periods_int
    data_est = data_est_int
    edu_start = edu_start_int
    is_myopic = is_myopic_int
    is_debug = is_debug_int
    min_idx = min_idx_int
    edu_max = edu_max_int
    delta = delta_int
    tau = tau_int

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF (ALLOCATED(mapping_state_idx)) DEALLOCATE(mapping_state_idx)
    IF (ALLOCATED(periods_payoffs_systematic)) DEALLOCATE(periods_payoffs_systematic)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)
    IF (ALLOCATED(periods_emax)) DEALLOCATE(periods_emax)
    IF (ALLOCATED(states_number_period)) DEALLOCATE(states_number_period)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)

    ! Solve requested model
    CALL fort_solve(periods_payoffs_systematic, states_number_period, mapping_state_idx, periods_emax, states_all, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, shocks_cholesky, periods_draws_emax_int, delta, is_debug, is_interpolated, is_myopic, edu_start, edu_max)

    ! Evaluate criterion function for observed data
    CALL fort_contributions(contribs, periods_payoffs_systematic, mapping_state_idx, periods_emax, states_all, shocks_cholesky, data_est, periods_draws_prob_int, delta, tau, edu_start, edu_max)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_simulate(data_sim_int, periods_payoffs_systematic_int, mapping_state_idx_int, periods_emax_int, states_all_int, shocks_cholesky, num_periods_int, edu_start_int, edu_max_int, delta_int, num_agents_sim_int, periods_draws_sims, seed_sim)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: data_sim_int(num_agents_sim_int * num_periods_int, 8)

    DOUBLE PRECISION, INTENT(IN)    :: periods_payoffs_systematic_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_sims(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: shocks_cholesky(4, 4)
    DOUBLE PRECISION, INTENT(IN)    :: periods_emax_int(:, :)
    DOUBLE PRECISION, INTENT(IN)    :: delta_int

    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: seed_sim

    INTEGER, INTENT(IN)             :: mapping_state_idx_int(:, :, :, :, :)
    INTEGER, INTENT(IN)             :: states_all_int(:, :, :)
    INTEGER, INTENT(IN)             :: num_agents_sim_int

    DOUBLE PRECISION, ALLOCATABLE   :: data_sim(:, :)
!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Assign global RESPFRT variables
    min_idx = SIZE(mapping_state_idx_int, 4)
    max_states_period = SIZE(states_all_int, 2)

    ! Transfer global RESFORT variables
    num_agents_sim = num_agents_sim_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    edu_max = edu_max_int
    delta = delta_int

    ! Call function of interest
    CALL fort_simulate(data_sim, periods_payoffs_systematic_int, mapping_state_idx_int, periods_emax_int, states_all_int, num_agents_sim, periods_draws_sims, shocks_cholesky, delta, edu_start, edu_max, seed_sim)

    ! Assign to initial objects for return to PYTHON
    data_sim_int = data_sim

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_backward_induction(periods_emax_int, num_periods_int, max_states_period_int, periods_draws_emax_int, num_draws_emax_int, states_number_period_int, periods_payoffs_systematic_int, edu_max_int, edu_start_int, mapping_state_idx_int, states_all_int, delta_int, is_debug_int, is_interpolated_int, num_points_interp_int, shocks_cholesky)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: periods_emax_int(num_periods_int, max_states_period_int)

    DOUBLE PRECISION, INTENT(IN)    :: periods_payoffs_systematic_int(:, :, :   )
    DOUBLE PRECISION, INTENT(IN)    :: periods_draws_emax_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)    :: shocks_cholesky(4, 4)
    DOUBLE PRECISION, INTENT(IN)    :: delta_int

    INTEGER, INTENT(IN)             :: mapping_state_idx_int(:, :, :, :, :)
    INTEGER, INTENT(IN)             :: states_number_period_int(:)
    INTEGER, INTENT(IN)             :: states_all_int(:, :, :)
    INTEGER, INTENT(IN)             :: max_states_period_int
    INTEGER, INTENT(IN)             :: num_draws_emax_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: num_points_interp_int
    INTEGER, INTENT(IN)             :: edu_start_int

    LOGICAL, INTENT(IN)             :: is_interpolated_int
    LOGICAL, INTENT(IN)             :: is_debug_int

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    !# Transfer auxiliary variable to global variable.
    max_states_period = max_states_period_int
    num_points_interp = num_points_interp_int
    is_interpolated = is_interpolated_int
    num_draws_emax = num_draws_emax_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    is_debug = is_debug_int
    edu_max = edu_max_int
    delta = delta_int

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF(ALLOCATED(periods_emax)) DEALLOCATE(periods_emax)

    ! Call actual function of interest
    CALL fort_backward_induction(periods_emax, periods_draws_emax_int, states_number_period_int, periods_payoffs_systematic_int, mapping_state_idx_int, states_all_int, shocks_cholesky, delta, is_debug, is_interpolated, .False., edu_start, edu_max, .False.)

    ! Allocate to intermidiaries
    periods_emax_int = periods_emax

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_create_state_space(states_all_int, states_number_period_int, mapping_state_idx_int, max_states_period_int, num_periods_int, edu_start_int, edu_max_int, min_idx_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    INTEGER, INTENT(OUT)            :: mapping_state_idx_int(num_periods_int, num_periods_int, num_periods_int, min_idx_int, 2)
    INTEGER, INTENT(OUT)            :: states_all_int(num_periods_int, 100000, 4)
    INTEGER, INTENT(OUT)            :: states_number_period_int(num_periods_int)
    INTEGER, INTENT(OUT)            :: max_states_period_int

    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: min_idx_int

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    !# Transfer global RESFORT variables
    max_states_period = max_states_period_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    min_idx = min_idx_int
    edu_max = edu_max_int

    states_all_int = MISSING_INT

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF (ALLOCATED(mapping_state_idx)) DEALLOCATE(mapping_state_idx)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)
    IF (ALLOCATED(states_number_period)) DEALLOCATE(states_number_period)
    IF (ALLOCATED(states_all)) DEALLOCATE(states_all)

    CALL fort_create_state_space(states_all, states_number_period, mapping_state_idx, edu_start, edu_max)

    states_all_int(:, :max_states_period, :) = states_all
    states_number_period_int = states_number_period

    ! Updated global variables
    mapping_state_idx_int = mapping_state_idx
    max_states_period_int = max_states_period

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE f2py_calculate_payoffs_systematic(periods_payoffs_systematic_int, num_periods_int, states_number_period_int, states_all_int, edu_start_int, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, max_states_period_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: periods_payoffs_systematic_int(num_periods_int, max_states_period_int, 4)

    DOUBLE PRECISION, INTENT(IN)    :: coeffs_home(1)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_edu(3)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_a(6)
    DOUBLE PRECISION, INTENT(IN)    :: coeffs_b(6)

    INTEGER, INTENT(IN)             :: states_number_period_int(:)
    INTEGER, INTENT(IN)             :: max_states_period_int
    INTEGER, INTENT(IN)             :: states_all_int(:,:,:)
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: edu_start_int

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Transfer global RESOFORT variables
    max_states_period = max_states_period_int
    num_periods = num_periods_int
    edu_start = edu_start_int

    ! Ensure that there is no problem with the repeated allocation of the containers.
    IF(ALLOCATED(periods_payoffs_systematic)) DEALLOCATE(periods_payoffs_systematic)

    ! Call function of interest
    CALL fort_calculate_payoffs_systematic(periods_payoffs_systematic, states_number_period_int, states_all_int, coeffs_a, coeffs_b, coeffs_edu, coeffs_home, edu_start)

    periods_payoffs_systematic_int = periods_payoffs_systematic

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_normal_pdf(rslt, x, mean, sd)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)      :: rslt

    DOUBLE PRECISION, INTENT(IN)       :: x
    DOUBLE PRECISION, INTENT(IN)       :: mean
    DOUBLE PRECISION, INTENT(IN)       :: sd

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    rslt = normal_pdf(x, mean, sd)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_pinv(rslt, A, m)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: rslt(m, m)

    DOUBLE PRECISION, INTENT(IN)    :: A(m, m)

    INTEGER, INTENT(IN)             :: m

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    rslt = pinv(A, m)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_svd(U, S, VT, A, m)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: S(m)
    DOUBLE PRECISION, INTENT(OUT)   :: U(m, m)
    DOUBLE PRECISION, INTENT(OUT)   :: VT(m, m)

    DOUBLE PRECISION, INTENT(IN)    :: A(m, m)

    INTEGER, INTENT(IN)             :: m

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL svd(U, S, VT, A, m)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_future_value(emax_simulated, num_periods_int, num_draws_emax_int, period, k, draws_emax_transformed, payoffs_systematic, edu_max_int, edu_start_int, periods_emax_int, states_all_int, mapping_state_idx_int, delta_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: emax_simulated

    DOUBLE PRECISION, INTENT(IN)    :: draws_emax_transformed(:,:)
    DOUBLE PRECISION, INTENT(IN)    :: payoffs_systematic(:)
    DOUBLE PRECISION, INTENT(IN)    :: periods_emax_int(:,:)
    DOUBLE PRECISION, INTENT(IN)    :: delta_int

    INTEGER, INTENT(IN)             :: mapping_state_idx_int(:,:,:,:,:)
    INTEGER, INTENT(IN)             :: states_all_int(:,:,:)
    INTEGER, INTENT(IN)             :: num_draws_emax_int
    INTEGER, INTENT(IN)             :: edu_max_int
    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: edu_start_int
    INTEGER, INTENT(IN)             :: period
    INTEGER, INTENT(IN)             :: k

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Assign global RESFORT variables
    max_states_period = SIZE(states_all_int, 2)
    min_idx = SIZE(mapping_state_idx_int, 4)

    !# Transfer global RESFORT variables
    num_draws_emax = num_draws_emax_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    edu_max = edu_max_int
    delta = delta_int

    ! Call function of interest
    CALL get_future_value(emax_simulated, draws_emax_transformed, period, k, payoffs_systematic, mapping_state_idx_int, states_all_int, periods_emax_int, delta, edu_start, edu_max)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_standard_normal(draw, dim)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    INTEGER, INTENT(IN)             :: dim

    DOUBLE PRECISION, INTENT(OUT)   :: draw(dim)

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL standard_normal(draw)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_determinant(det, A)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: det

    DOUBLE PRECISION, INTENT(IN)    :: A(:, :)

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    det = determinant(A)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_inverse(inv, A, n)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: inv(n, n)

    DOUBLE PRECISION, INTENT(IN)    :: A(:, :)

    INTEGER, INTENT(IN)             :: n

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    inv = inverse(A, n)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_trace(rslt, A)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT) :: rslt

    DOUBLE PRECISION, INTENT(IN)  :: A(:,:)

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    rslt = trace_fun(A)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_clip_value(clipped_value, value, lower_bound, upper_bound, num_values)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)       :: clipped_value(num_values)

    DOUBLE PRECISION, INTENT(IN)        :: value(:)
    DOUBLE PRECISION, INTENT(IN)        :: lower_bound
    DOUBLE PRECISION, INTENT(IN)        :: upper_bound

    INTEGER, INTENT(IN)                 :: num_values

    !/* internal objects        */

    INTEGER, ALLOCATABLE                :: infos(:)

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL clip_value(clipped_value, value, lower_bound, upper_bound, infos)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_pred_info(r_squared, bse, Y, P, X, num_states, num_covars)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: bse(num_covars)
    DOUBLE PRECISION, INTENT(OUT)   :: r_squared

    DOUBLE PRECISION, INTENT(IN)    :: X(num_states, num_covars)
    DOUBLE PRECISION, INTENT(IN)    :: Y(num_states)
    DOUBLE PRECISION, INTENT(IN)    :: P(num_states)

    INTEGER, INTENT(IN)             :: num_states
    INTEGER, INTENT(IN)             :: num_covars

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL get_pred_info(r_squared, bse, Y, P, X, num_states, num_covars)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_point_predictions(Y, X, coeffs, num_states)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)       :: Y(num_states)

    DOUBLE PRECISION, INTENT(IN)        :: coeffs(:)
    DOUBLE PRECISION, INTENT(IN)        :: X(:,:)

    INTEGER, INTENT(IN)                 :: num_states

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL point_predictions(Y, X, coeffs, num_states)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_predictions(predictions, endogenous, exogenous, maxe, is_simulated, num_points_interp_int, num_states)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)               :: predictions(num_states)

    DOUBLE PRECISION, INTENT(IN)                :: exogenous(:, :)
    DOUBLE PRECISION, INTENT(IN)                :: endogenous(:)
    DOUBLE PRECISION, INTENT(IN)                :: maxe(:)

    INTEGER, INTENT(IN)                         :: num_states
    INTEGER, INTENT(IN)                         :: num_points_interp_int

    LOGICAL, INTENT(IN)                         :: is_simulated(:)

!------------------------------------------------------------------------------
! Algorithm

!------------------------------------------------------------------------------

    ! Transfer global RESFORT variables
    num_points_interp = num_points_interp_int

    ! Call function of interest
    CALL get_predictions(predictions, endogenous, exogenous, maxe, is_simulated, num_states)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_random_choice(sample, candidates, num_candidates, num_points)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    INTEGER, INTENT(OUT)            :: sample(num_points)

    INTEGER, INTENT(IN)             :: candidates(:)
    INTEGER, INTENT(IN)             :: num_candidates
    INTEGER, INTENT(IN)             :: num_points

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
     CALL random_choice(sample, candidates, num_candidates, num_points)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_coefficients(coeffs, Y, X, num_covars, num_states)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: coeffs(num_covars)

    DOUBLE PRECISION, INTENT(IN)    :: X(:,:)
    DOUBLE PRECISION, INTENT(IN)    :: Y(:)

    INTEGER, INTENT(IN)             :: num_covars
    INTEGER, INTENT(IN)             :: num_states

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Call function of interest
    CALL get_coefficients(coeffs, Y, X, num_covars, num_states)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_endogenous_variable(exogenous_variable, period, num_periods_int, num_states, delta_int, periods_payoffs_systematic_int, edu_max_int, edu_start_int, mapping_state_idx_int, periods_emax_int, states_all_int, is_simulated, num_draws_emax_int, maxe, draws_emax_transformed)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)       :: exogenous_variable(num_states)

    DOUBLE PRECISION, INTENT(IN)        :: periods_payoffs_systematic_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)        :: draws_emax_transformed(:, :)
    DOUBLE PRECISION, INTENT(IN)        :: periods_emax_int(:, :)
    DOUBLE PRECISION, INTENT(IN)        :: maxe(:)
    DOUBLE PRECISION, INTENT(IN)        :: delta_int

    INTEGER, INTENT(IN)                 :: mapping_state_idx_int(:, :, :, :, :)
    INTEGER, INTENT(IN)                 :: states_all_int(:, :, :)
    INTEGER, INTENT(IN)                 :: num_draws_emax_int
    INTEGER, INTENT(IN)                 :: edu_max_int
    INTEGER, INTENT(IN)                 :: num_periods_int
    INTEGER, INTENT(IN)                 :: num_states
    INTEGER, INTENT(IN)                 :: edu_start_int
    INTEGER, INTENT(IN)                 :: period

    LOGICAL, INTENT(IN)                 :: is_simulated(:)

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    ! Transfer global RESFORT variables
    num_draws_emax = num_draws_emax_int
    num_periods = num_periods_int
    edu_start = edu_start_int
    edu_max = edu_max_int
    delta = delta_int

    ! Call function of interest
    CALL get_endogenous_variable(exogenous_variable, period, num_states, periods_payoffs_systematic_int, mapping_state_idx_int, periods_emax_int, states_all_int, is_simulated, maxe, draws_emax_transformed, delta, edu_start, edu_max)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_exogenous_variables(independent_variables, maxe, period, num_periods_int, num_states, delta_int, periods_payoffs_systematic_int, shifts, edu_max_int, edu_start_int, mapping_state_idx_int, periods_emax_int, states_all_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)        :: independent_variables(num_states, 9)
    DOUBLE PRECISION, INTENT(OUT)        :: maxe(num_states)

    DOUBLE PRECISION, INTENT(IN)        :: periods_payoffs_systematic_int(:, :, :)
    DOUBLE PRECISION, INTENT(IN)        :: periods_emax_int(:, :)
    DOUBLE PRECISION, INTENT(IN)        :: shifts(:)
    DOUBLE PRECISION, INTENT(IN)        :: delta_int

    INTEGER, INTENT(IN)                 :: mapping_state_idx_int(:, :, :, :, :)
    INTEGER, INTENT(IN)                 :: states_all_int(:, :, :)
    INTEGER, INTENT(IN)                 :: edu_max_int
    INTEGER, INTENT(IN)                 :: num_periods_int
    INTEGER, INTENT(IN)                 :: num_states
    INTEGER, INTENT(IN)                 :: edu_start_int
    INTEGER, INTENT(IN)                 :: period

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    !# Assign global RESFORT variables
    max_states_period = SIZE(states_all_int, 2)
    min_idx = SIZE(mapping_state_idx_int, 4)

    !# Transfer global RESFORT variables
    num_periods = num_periods_int
    edu_start = edu_start_int
    edu_max = edu_max_int
    delta = delta_int

    ! Call function of interest
    CALL get_exogenous_variables(independent_variables, maxe, period, num_states, periods_payoffs_systematic_int, shifts, mapping_state_idx_int, periods_emax_int, states_all_int, delta, edu_start, edu_max)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_simulated_indicator(is_simulated, num_points, num_states, period, is_debug_int, num_periods_int)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    LOGICAL, INTENT(OUT)            :: is_simulated(num_states)

    INTEGER, INTENT(IN)             :: num_periods_int
    INTEGER, INTENT(IN)             :: num_states
    INTEGER, INTENT(IN)             :: num_points
    INTEGER, INTENT(IN)             :: period

    LOGICAL, INTENT(IN)             :: is_debug_int

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    !# Transfer global RESFORT variables
    num_periods = num_periods_int
    is_debug = is_debug_int

    ! Call function of interest
    is_simulated = get_simulated_indicator(num_points, num_states, period, .True.)

END SUBROUTINE
!******************************************************************************
!******************************************************************************
SUBROUTINE wrapper_get_cholesky(shocks_cholesky, info, x)

    !/* external libraries      */

    USE resfort_library

    !/* setup                   */

    IMPLICIT NONE

    !/* external objects        */

    DOUBLE PRECISION, INTENT(OUT)   :: shocks_cholesky(4, 4)

    DOUBLE PRECISION, INTENT(IN)    :: x(26)

    INTEGER, INTENT(OUT)            :: info

!------------------------------------------------------------------------------
! Algorithm
!------------------------------------------------------------------------------

    CALL get_cholesky(shocks_cholesky, x, info)

END SUBROUTINE
!******************************************************************************
!******************************************************************************


text:
Testing an ordered list:

1. First item
2. Second item
3. Third item


text:
package org.marketcetera.util.misc;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import org.apache.commons.lang.ArrayUtils;
import org.junit.Test;
import org.marketcetera.util.except.I18NInterruptedRuntimeException;
import org.marketcetera.util.test.TestCaseBase;

import static org.junit.Assert.*;
import static org.marketcetera.util.test.CollectionAssert.*;

/**
 * @author tlerios@marketcetera.com
 * @since 0.6.0
 * @version $Id: ReflectUtilsTest.java 16154 2012-07-14 16:34:05Z colin $
 */

/* $License$ */

public class ReflectUtilsTest
    extends TestCaseBase
{
    private static final String OBJECT_NAME=
        Object.class.getName();
    private static final String EMPTY_NAME=
        Empty.class.getName();
    private static final String SIMPLE_NAME=
        Simple.class.getName();
    private static final String DERIVED_NAME=
        Derived.class.getName();
    private static final String IFACE_NAME=
        IFace.class.getName();
    private static final String COMPLEX_BASE_NAME=
        ComplexBase.class.getName();
    private static final String COMPLEX_DERIVED_NAME=
        ComplexDerived.class.getName();

    private static final String SIMPLE_FIELD=
        "mSimple";
    private static final String DERIVED_FIELD=
        "mDerived";
    private static final String IFACE_FIELD=
        "mIFace";
    private static final String COMPLEX_BASE_FIELD=
        "mComplexBase";
    private static final String COMPLEX_DERIVED_FIELD=
        "mComplexDerived";

    private static class Empty {}

    private static class Simple
    {
        int mSimple;
    }

    private static class Derived
        extends Simple
    {
        int mDerived;
    }

    private static interface IFace
    {
        int mIFace=0;
    }

    private static class ComplexBase
        extends Simple
        implements IFace
    {
        int mComplexBase;
    }

    private static class ComplexDerived
        extends ComplexBase
        implements IFace
    {
        int mComplexDerived;
    }

    private static class IntObject
    {
        private int mValue;

        public IntObject
            (int value)
        {
            if (value==0) {
                throw new I18NInterruptedRuntimeException();
            }
            mValue=value;
        }

        public int getValue()
        {
            return mValue;
        }
    }

    private static void assertNamesMatch
        (String[] expectedNames,
         Field[] fields)
    {
        String[] actualNames=new String[fields.length];
        for (int i=0;i<fields.length;i++) {
            actualNames[i]=fields[i].getName();
        }
        assertArrayPermutation(expectedNames,actualNames);
    }

    private static void assertNamesMatch
        (String[] expectedNames,
         Class<?>[] classes)
    {
        String[] actualNames=new String[classes.length];
        for (int i=0;i<classes.length;i++) {
            actualNames[i]=classes[i].getName();
        }
        assertArrayPermutation(expectedNames,actualNames);
    }

    @Test
    public void classes()
    {
        assertNamesMatch
            (new String[] {
                OBJECT_NAME,
                EMPTY_NAME
            },ReflectUtils.getAllClasses(Empty.class));
        assertNamesMatch
            (new String[] {
                OBJECT_NAME,
                SIMPLE_NAME
            },ReflectUtils.getAllClasses(Simple.class));
        assertNamesMatch
            (new String[] {
                OBJECT_NAME,
                SIMPLE_NAME,
                DERIVED_NAME
            },ReflectUtils.getAllClasses(Derived.class));
        assertNamesMatch
            (new String[] {
                IFACE_NAME
            },ReflectUtils.getAllClasses(IFace.class));
        assertNamesMatch
            (new String[] {
                OBJECT_NAME,
                SIMPLE_NAME,
                IFACE_NAME,
                COMPLEX_BASE_NAME
            },ReflectUtils.getAllClasses(ComplexBase.class));
        assertNamesMatch
            (new String[] {
                OBJECT_NAME,
                SIMPLE_NAME,
                IFACE_NAME,
                COMPLEX_BASE_NAME,
                COMPLEX_DERIVED_NAME
            },ReflectUtils.getAllClasses(ComplexDerived.class));
    }

    @Test
    public void fields()
    {
        assertNamesMatch
            (ArrayUtils.EMPTY_STRING_ARRAY,
             ReflectUtils.getAllFields(Empty.class));
        assertNamesMatch
            (new String[] {
                SIMPLE_FIELD
            },ReflectUtils.getAllFields(Simple.class));
        assertNamesMatch
            (new String[] {
                SIMPLE_FIELD,
                DERIVED_FIELD
            },ReflectUtils.getAllFields(Derived.class));
        assertNamesMatch
            (new String[] {
                IFACE_FIELD
            },ReflectUtils.getAllFields(IFace.class));
        assertNamesMatch
            (new String[] {
                SIMPLE_FIELD,
                IFACE_FIELD,
                COMPLEX_BASE_FIELD
            },ReflectUtils.getAllFields(ComplexBase.class));
        assertNamesMatch
            (new String[] {
                SIMPLE_FIELD,
                IFACE_FIELD,
                COMPLEX_BASE_FIELD,
                COMPLEX_DERIVED_FIELD
            },ReflectUtils.getAllFields(ComplexDerived.class));
    }

    @Test
    public void instance()
        throws Exception
    {
        assertEquals(1,((IntObject)
                        (ReflectUtils.getInstance
                         (IntObject.class.getName(),
                          new Class[] {Integer.TYPE},
                          new Object[] {new Integer(1)}))).getValue());
        try {
            ReflectUtils.getInstance("NonExistent",null,null);
            fail();
        } catch (ClassNotFoundException ex) {
            assertFalse(Thread.interrupted());
        }
        try {
            ReflectUtils.getInstance(IntObject.class.getName(),
                                     new Class[] {Integer.TYPE},
                                     new Object[] {new Integer(0)});
            fail();
        } catch (InvocationTargetException ex) {
            assertTrue(Thread.interrupted());
            assertEquals(I18NInterruptedRuntimeException.class,
                         ex.getCause().getClass());
        }
    }
}


text:
Project cHasky is a tiny implementation of Computation Graph. It will include some basic models(layers) of Artifical Neural Networks.

To make it funny and different, we will forcus on data visualization for NNs.

## DNN demo

Project cHasky supports python languages to write graph configuration.

For example, to build a simple Neural Network, configurations like

    from chasky import functions
    import chasky.chasky_engine as engine
    from chasky.config_helper import Node, Edge, \
        CreateGraph, DestroyGraph, GraphStringBuffer, GraphDebugString, DataProvider, \
        Field

    batch_size = 30

    # create a demo graph
    CreateGraph("demo_graph")

    data_provider = DataProvider("data_provider",
                  './1.txt',
                  batch_size,
                  Field("feature", "float_mat",
                        dim=30, doc="first feature"),
                  Field("label", "float_mat",
                        dim=1, doc="prediction label"))
    Node("layer1", functions.FullyConnectedFunc(50, batch_size))
    Node("layer2", functions.FullyConnectedFunc(1, batch_size))
    Node("loss_layer", functions.RMSElossFunc(), is_end=True)
    Edge("data_provider", "feature", "layer1", "input")
    Edge("layer1", "output", "layer2", "input")
    Edge("layer2", "output", "loss_layer", "target")
    Edge("data_provider", "label", "loss_layer", "label")

    # init session
    session = engine.Session()
    session.CreateGraph(GraphStringBuffer())
    session.StartExec()

    # start training
    for batch in data_provider.batchs():
        session.Compute(batch)

In addition to python language, following C++ APIs are available:

    cHasky/chasky/core/framework/argument_def_builder.h
    cHasky/chasky/core/framework/data_provider_def_builder.h
    cHasky/chasky/core/framework/edge_def_builder.h
    cHasky/chasky/core/framework/function_def_builder.h
    cHasky/chasky/core/framework/graph_def_builder.h
    cHasky/chasky/core/framework/node_def_builder.h

and supports syntax like:

    auto graph_builder = GraphDefBuilder().Name("demo_graph");

    auto data_provider_def = DataProviderDefBuilder()
                                 .Name("data-provider")
                                 .Field(ArgumentDefBuilder()
                                            .Name("id")
                                            .Type("float_mat")
                                            .Shape(dim, batch_size)
                                            .Finalize())
                                 .Finalize();

    auto node_def_1 =
        NodeDefBuilder()
            .Name("node-1")
            .Signature("IdenticalFunc:11")
            .Attr("dim", AttrValueBuilder().Value(dim).Finalize())
            .Attr("batch_size", AttrValueBuilder().Value(batch_size).Finalize())
            .Finalize();
    auto node_def_2 =
        NodeDefBuilder()
            .Name("node-2")
            .Signature("IdenticalFunc:11")
            .Attr("dim", AttrValueBuilder().Value(dim).Finalize())
            .Attr("batch_size", AttrValueBuilder().Value(batch_size).Finalize())
            .Finalize();
    auto node_def_3 =
        NodeDefBuilder()
            .Name("node-3")
            .SetIsEnd(true)
            .Signature("IdenticalFunc:11")
            .Attr("dim", AttrValueBuilder().Value(dim).Finalize())
            .Attr("batch_size", AttrValueBuilder().Value(batch_size).Finalize())
            .Finalize();

    auto edge_def_1 = EdgeDefBuilder()
                          .SrcNode("node-1")
                          .SrcArg("output")
                          .TrgNode("node-2")
                          .TrgArg("input")
                          .Finalize();

    auto edge_def_2 = EdgeDefBuilder()
                          .SrcNode("node-2")
                          .SrcArg("output")
                          .TrgNode("node-3")
                          .TrgArg("input")
                          .Finalize();

    auto edge_def_3 = EdgeDefBuilder()
                          .SrcNode("data-provider")
                          .SrcArg("id")
                          .TrgNode("node-1")
                          .TrgArg("input")
                          .Finalize();

    graph_def = graph_builder.AddNode(node_def_1)
                    .SetDataProvider(data_provider_def)
                    .AddNode(node_def_2)
                    .AddNode(node_def_3)
                    .AddEdge(edge_def_1)
                    .AddEdge(edge_def_2)
                    .AddEdge(edge_def_3)
                    .Finalize();

# NOTE

This project is under development, and no release is ready now.


text:
NOXIS_NS_BEGIN;

Texture::Texture(const std::string &path) : Resource(path) {
    texture = IMG_LoadTexture(Engine::getInstance()->getRenderer()->getSDLRenderer(), path.c_str());
    if(texture == nullptr) {
        throw std::runtime_error(std::string("Can't load texture: ") + IMG_GetError());
    }

    SDL_QueryTexture(texture, nullptr, nullptr, &size.width, &size.height);
}

int Texture::getWidth() const {
    return size.width;
}

int Texture::getHeight() const {
    return size.height;
}

const Size& Texture::getSize() const {
    return size;
}

Texture::~Texture() {
    SDL_DestroyTexture(texture);
}

NOXIS_NS_END;