text:
<?php

// Register deprecated filters ( $deprecated, $version, $replacement ).
acf_add_deprecated_filter( 'acf/settings/export_textdomain',	'5.3.3', 'acf/settings/l10n_textdomain' );
acf_add_deprecated_filter( 'acf/settings/export_translate',		'5.3.3', 'acf/settings/l10n_field' );
acf_add_deprecated_filter( 'acf/settings/export_translate',		'5.3.3', 'acf/settings/l10n_field_group' );
acf_add_deprecated_filter( 'acf/settings/dir',					'5.6.8', 'acf/settings/url' );
acf_add_deprecated_filter( 'acf/get_valid_field',				'5.5.6', 'acf/validate_field' );
acf_add_deprecated_filter( 'acf/get_valid_field_group',			'5.5.6', 'acf/validate_field_group' );
acf_add_deprecated_filter( 'acf/get_valid_post_id',				'5.5.6', 'acf/validate_post_id' );
acf_add_deprecated_filter( 'acf/get_field_reference',			'5.6.5', 'acf/load_reference' );
acf_add_deprecated_filter( 'acf/get_field_group',				'5.7.11', 'acf/load_field_group' );
acf_add_deprecated_filter( 'acf/get_field_groups',				'5.7.11', 'acf/load_field_groups' );
acf_add_deprecated_filter( 'acf/get_fields',					'5.7.11', 'acf/load_fields' );

// Register variations for deprecated filters.
acf_add_filter_variations( 'acf/get_valid_field', array('type'), 0 );

/**
 * acf_render_field_wrap_label
 *
 * Renders the field's label.
 *
 * @date	19/9/17
 * @since	5.6.3
 * @deprecated 5.6.5
 *
 * @param	array $field The field array.
 * @return	void
 */
function acf_render_field_wrap_label( $field ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.7.11', 'acf_render_field_label()' );

	// Render.
	acf_render_field_label( $field );
}

/**
 * acf_render_field_wrap_description
 *
 * Renders the field's instructions.
 *
 * @date	19/9/17
 * @since	5.6.3
 * @deprecated 5.6.5
 *
 * @param	array $field The field array.
 * @return	void
 */
function acf_render_field_wrap_description( $field ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.7.11', 'acf_render_field_instructions()' );

	// Render.
	acf_render_field_instructions( $field );
}

/*
 * acf_get_fields_by_id
 *
 * Returns and array of fields for the given $parent_id.
 *
 * @date	27/02/2014
 * @since	5.0.0.
 * @deprecated	5.7.11
 *
 * @param	int $parent_id The parent ID.
 * @return	array
 */
function acf_get_fields_by_id( $parent_id = 0 ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.7.11', 'acf_get_fields()' );

	// Return fields.
	return acf_get_fields(array( 'ID' => $parent_id, 'key' => "group_$parent_id" ));
}

/**
 * acf_update_option
 *
 * A wrapper for the WP update_option but provides logic for a 'no' autoload
 *
 * @date	4/01/2014
 * @since	5.0.0
 * @deprecated	5.7.11
 *
 * @param	string $option The option name.
 * @param	string $value The option value.
 * @param	string $autoload An optional autoload value.
 * @return	bool
 */
function acf_update_option( $option = '', $value = '', $autoload = null ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.7.11', 'update_option()' );

	// Update.
	if( $autoload === null ) {
		$autoload = (bool) acf_get_setting('autoload');
	}
	return update_option( $option, $value, $autoload );
}

/**
 * acf_get_field_reference
 *
 * Finds the field key for a given field name and post_id.
 *
 * @date	26/1/18
 * @since	5.6.5
 * @deprecated	5.6.8
 *
 * @param	string	$field_name	The name of the field. eg 'sub_heading'
 * @param	mixed	$post_id	The post_id of which the value is saved against
 * @return	string	$reference	The field key
 */
function acf_get_field_reference( $field_name, $post_id ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.6.8', 'acf_get_reference()' );

	// Return reference.
	return acf_get_reference( $field_name, $post_id );
}

/**
 * acf_get_dir
 *
 * Returns the plugin url to a specified file.
 *
 * @date	28/09/13
 * @since	5.0.0
 * @deprecated	5.6.8
 *
 * @param	string $filename The specified file.
 * @return	string
 */
function acf_get_dir( $filename = '' ) {

	// Warning.
	_deprecated_function( __FUNCTION__, '5.6.8', 'acf_get_url()' );

	// Return.
	return acf_get_url( $filename );
}


text:
package com.google.gerrit.common.data;

import com.google.gerrit.reviewdb.Project;

public class ProjectDetail {
  public Project project;
  public boolean canModifyDescription;
  public boolean canModifyMergeType;
  public boolean canModifyAgreements;
  public boolean canModifyAccess;

  public ProjectDetail() {
  }

  public void setProject(final Project p) {
    project = p;
  }

  public void setCanModifyDescription(final boolean cmd) {
    canModifyDescription = cmd;
  }

  public void setCanModifyMergeType(final boolean cmmt) {
    canModifyMergeType = cmmt;
  }

  public void setCanModifyAgreements(final boolean cma) {
    canModifyAgreements = cma;
  }

  public void setCanModifyAccess(final boolean cma) {
    canModifyAccess = cma;
  }
}

redpajama_set_name: RedPajamaGithub


text:
namespace System.IO.Pipelines.Networking.Libuv.Interop
{
    public class UvPipeHandle : UvStreamHandle
    {
        public UvPipeHandle() : base()
        {
        }

        public void Init(UvLoopHandle loop, Action<Action<IntPtr>, IntPtr> queueCloseHandle, bool ipc = false)
        {
            CreateHandle(
                loop.Libuv,
                loop.ThreadId,
                loop.Libuv.handle_size(Uv.HandleType.NAMED_PIPE), queueCloseHandle);

            _uv.pipe_init(loop, this, ipc);
        }

        public void Bind(string name)
        {
            _uv.pipe_bind(this, name);
        }

        public int PendingCount()
        {
            return _uv.pipe_pending_count(this);
        }
    }
}


text:
<?php
// grab the encrypted properties file
require_once("/etc/apache2/capstone-mysql/encrypted-config.php");

/**
 * Abstract class containing universal and project specific mySQL parameters
 *
 * This class is designed to lay the foundation of the unit tests per project. It loads the all the database
 * parameters about the project so that table specific tests can share the parameters in on place. To use it:
 *
 * 1. Rename the class from DataDesignTest to a project specific name (e.g., ProjectNameTest)
 *   "renamed to KarmaTest"
 * 2. Modify KarmaTest::getDataSet() to include all the tables in your project.
 * 3. Modify Karma-Base-Test::getConnection() to include the correct mySQL properties file.
 * 4. Have all table specific tests include this class.
 *
 * *NOTE*: Tables must be added in the order they were created in step (2).
 *
 * @author Gerald <gfongwe@cnm.edu>
 **/
abstract class KarmaDataDesign extends PHPUnit_Extensions_Database_TestCase {
	/**
	 * invalid id to use for an INT UNSIGNED field (maximum allowed INT UNSIGTNED in mySQL) + 1
	 * @see https://dev.mysql.com/doc/refman/5.6/en/integer-types.html mySQL Integer Types
	 * @var int INVALID_KEY
	 **/
	const INVALID_KEY = 4294967296;

	/**
	 * PHPUnit database connection interface
	 * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection
	 **/
	protected $connection = null;

	/**
	 * assembles the table from the schema and provides it to PHPUnit
	 *
	 * @return PHPUnit_Extensions_Database_DataSet_QueryDataSet assembled schema for PHPUnit
	 **/
	public final function getDataSet() {
		$dataset = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection());

		// add all the tables for the project here
		// THESE TABLES *MUST* BE LISTED IN THE SAME ORDER THEY WERE CREATED!!!!
		$dataset->addTable("member");
		$dataset->addTable("profile");
		$dataset->addTable("message");
		$dataset->addTable("need");
		$dataset->addTable("karma");

		return($dataset);
	}

	/**
	 * templates the setUp method that runs before each test; this method expunges the database before each run
	 *
	 *
	 *
	 * @see https://phpunit.de/manual/current/en/fixtures.html#fixtures.more-setup-than-teardown PHPUnit Fixtures: setUp and tearDown
	 * @see https://github.com/sebastianbergmann/dbunit/issues/37 TRUNCATE fails on tables which have foreign key constraints
	 * @return PHPUnit_Extensions_Database_Operation_Composite array containing delete and insert commands
	 **/
	public final function getSetUpOperation() {
		return new PHPUnit_Extensions_Database_Operation_Composite(array(
			PHPUnit_Extensions_Database_Operation_Factory::DELETE_ALL(),
			PHPUnit_Extensions_Database_Operation_Factory::INSERT()
		));
	}

	/**
	 * templates the tearDown method that runs after each test; this method expunges the database after each run
	 *
	 * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation delete command for the database
	 **/
	public final function getTearDownOperation() {
		return(PHPUnit_Extensions_Database_Operation_Factory::DELETE_ALL());
	}

	/**
	 * sets up the database connection and provides it to PHPUnit
	 *
	 * @see <https://phpunit.de/manual/current/en/database.html#database.configuration-of-a-phpunit-database-testcase>
	 * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection PHPUnit database connection interface
	 **/
	public final function getConnection() {
		// if the connection hasn't been established, create it
		if($this->connection === null) {
			// grab the encrypted mySQL properties file and create the DSN
			$config = readConfig("/etc/apache2/capstone-mysql/karma.ini");
			$dsn = "mysql:host=" . $config["hostname"] . ";dbname=" . $config["database"];
			$options = array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8");

			// provide the interface to PHPUnit
			$pdo = new PDO($dsn, $config["username"], $config["password"], $options);
			$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
			$this->connection = $this->createDefaultDBConnection($pdo, $config["database"]);
		}
		return($this->connection);
	}

	/**
	 * returns the actual PDO object; this is a convenience method
	 *
	 * @return PDO active PDO object
	 **/
	public final function getPDO() {
		return($this->getConnection()->getConnection());
	}
}


text:
// Copyright (c) Jupyter Development Team.
// Distributed under the terms of the Modified BSD License.
'use strict';

import {
  IChangedArgs
} from 'phosphor-properties';

import {
  Widget
} from 'phosphor-widget';

import {
  PanelLayout
} from 'phosphor-panel';

import {
  CodeMirrorWidget, IEditorModel, IEditorWidget
} from '../editor';

import {
  IInputAreaModel
} from './model';

/**
 * The class name added to input area widgets.
 */
const INPUT_CLASS = 'jp-InputArea';

/**
 * The class name added to the prompt area of the input area.
 */
const PROMPT_CLASS = 'jp-InputArea-prompt';

/**
 * The class name added to the editor area of the input area.
 */
const EDITOR_CLASS = 'jp-InputArea-editor';

/**
 * The class name added to the input area when collapsed.
 */
const COLLAPSED_CLASS = 'jp-mod-collapsed';

/**
 * The class name added to to the input area when readonly.
 */
const READONLY_CLASS = 'jp-mod-readOnly';

/**
 * An input area widget, which hosts an editor widget.
 */
export
class InputAreaWidget extends Widget {
  /**
   * Create a new editor widget.
   */
  static createEditor(model: IEditorModel): IEditorWidget {
    return new CodeMirrorWidget(model);
  }

  /**
   * Construct an input area widget.
   */
  constructor(model: IInputAreaModel) {
    super();
    this.addClass(INPUT_CLASS);
    this._model = model;
    this.layout = new PanelLayout();
    this._prompt = new Widget();
    this._prompt.addClass(PROMPT_CLASS);
    let prompt = model.prompt;
    if (prompt !== null) {
      this.prompt.node.textContent = `In [${prompt || ' '}]:`;
    }
    let constructor = this.constructor as typeof InputAreaWidget;
    this._editor = constructor.createEditor(model.textEditor);
    this._editor.addClass(EDITOR_CLASS);
    let layout = this.layout as PanelLayout;
    layout.addChild(this._prompt);
    layout.addChild(this._editor);
    model.stateChanged.connect(this.onModelUpdated, this);
  }

  /**
   * Get the model used by the widget.
   *
   * #### Notes
   * This is a read-only property.
   */
  get model(): IInputAreaModel {
    return this._model;
  }

  /**
   * Get the editor widget used by the widget.
   *
   * #### Notes
   * This is a read-only property.
   */
  get editor(): IEditorWidget {
    return this._editor;
  }

  /**
   * Get the prompt widget for the input area.
   *
   * #### Notes
   * This is a read-only property.
   */
  get prompt(): Widget {
    return this._prompt;
  }

  /**
   * Dispose of the resources held by the widget.
   */
  dispose() {
    this._model.dispose();
    this._model = null;
    super.dispose();
  }

  /**
   * Change handler for model updates.
   */
  protected onModelUpdated(sender: IInputAreaModel, args: IChangedArgs<any>) {
    switch (args.name) {
    case 'collapsed':
      if (args.newValue) {
        this.addClass(COLLAPSED_CLASS);
      } else {
        this.removeClass(COLLAPSED_CLASS);
      }
      break;
    case 'readOnly':
      if (args.newValue) {
        this.addClass(READONLY_CLASS);
      } else {
        this.removeClass(READONLY_CLASS);
      }
      break;
    case 'prompt':
      if (args.newValue === null) {
        this.prompt.node.textContent = '';
      } else {
        this.prompt.node.textContent = `In [${args.newValue || ' '}]:`;
      }
      break;
    }
  }

  private _model: IInputAreaModel = null;
  private _editor: IEditorWidget = null;
  private _prompt: Widget = null;
}


text:
<TITLE>Review for Ransom (1996)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

Ransom (1996)

reviewed by
George McAdams

                                    RANSOM
                       A film review by George McAdams
                        Copyright 1996 George McAdams

Movie Grade 3.5 out of 4, Web Site Grade 4 out of 4

Moviegoers have reasons to begin celebrating the early arrival of the
holiday season with the pre-Thanksgiving release of "Ransom (
http://www.movies.com/rn/shock.html ), Ron Howard's latest film,
starring Mel Gibson, Rene Russo, Delroy Lindo, and Gary Sinise. With the
expected glut of sugar-coated holiday films just around the corner, this
is one you'll be able to return to for repeated viewings; however, don't
get out your magnifying glass too much, or you'll find some scenes will
leave you with questions.

This emotional action/drama that centers around the kidnapping of the
son of an airline mogul, Tom Mullen, played by Gibson, delivers the
wrenching conflicts of parents faced with the dilemma of how to get back
their son from an abductor, played by Sinise, whose systematic plan to
obtain a ransom is second only in his desire to get plebe's justice from
the rich Gibson, which adds more psychological weight to the
teeter-tottering the protagonist and antagonist give each other with
each downward thrust of their human character. While most kidnappings
envolve around the waiting and wondering about whether the person
kidnapped will be released, Gibson takes control of the situation by
using the ransom as a $2,000,000 reward for the person who turns-in the
kidnappers.

The righteous indignation displayed by Gibson is similar to others in
films, Harrison Ford in "Patriot Games," and even Charlie Sheen in "Wall
Street," come to mind; but, Gibson transcends this one-level response by
his physical reaction to the dramatic landmind that explodes when he
collapses soon after he realizes his proactive actions may have led to
his son being shot by the kidnappers.

Ransom is a movie that fully delivers, with none of the actors giving a
weak, or even lukewarm, performance. Even young Brawley Nolte, Nick
Nolte's son, deliver's out-of-the-gate. The small twists of illogic that
crop-up from time to time, only serve as reminders of just how complex
movies are, but given that Howard has worked dramas before, "Backdraft,"
et.al., it is disappointing that they are there.

As for the Ransom ( http://www.movies.com/rn/mainmenu.html ) Web site,
there are:
 Background notes on Director Ron Howard ( http://www.movies.com/rn/ronhoward/ronhoward.html ),
 An interview with Howard (
http://www.movies.com/rn/ronhoward/interview.html ),
 Details about the premiere (
http://www.movies.com/rn/premiere/premiere.html ),
 Cast Interviews ( http://www.movies.com/rn/cast/cast.html ),
 The obligatory Shockwave trailer (
http://www.movies.com/rn/trailer/trailer.html ),
 An "ask the stars section (
http://www.movies.com/rn/askthestars/askthestars.html ), and
 AVI and Quicktime scenes with Howard discussing the story (
http://www.movies.com/rn/story/story.html ), the audience, and even the
Internet ( http://.www.movies.com/cpk/ron5.mov).

The Web Site gets a 4 out of 4 rating, but be warned, the amount of
information here is not fluff.  Give yourself at least an hour to just
read everything.

For other links to movie sites, be sure to check out the
Movies-in-the-Net site at
( http://www.primenet.com/~george )

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews


text:
from test.integration.base import DBTIntegrationTest, use_profile

class TestCustomSchema(DBTIntegrationTest):
    def setUp(self):
        super().setUp()
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v2_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.xf_schema())
        )

    @property
    def schema(self):
        return "custom_schema_024"

    @property
    def models(self):
        return "models"

    def v2_schema(self):
        return f"{self.unique_schema()}_custom"

    def xf_schema(self):
        return f"{self.unique_schema()}_test"

    @use_profile('postgres')
    def test__postgres__custom_schema_no_prefix(self):
        self.run_sql_file("seed.sql")

        results = self.run_dbt()
        self.assertEqual(len(results), 3)

        schema = self.unique_schema()

        self.assertTablesEqual("seed", "view_1")
        self.assertTablesEqual("seed", "view_2", schema, self.v2_schema())
        self.assertTablesEqual("agg", "view_3", schema, self.xf_schema())

class TestCustomProjectSchemaWithPrefix(DBTIntegrationTest):
    def setUp(self):
        super().setUp()
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v1_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v2_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.xf_schema())
        )

    @property
    def schema(self):
        return "custom_prefix_024"

    @property
    def models(self):
        return "models"

    @property
    def profile_config(self):
        return {
            'test': {
                'outputs': {
                    'my-target': {
                        'type': 'postgres',
                        'threads': 1,
                        'host': self.database_host,
                        'port': 5432,
                        'user': 'root',
                        'pass': 'password',
                        'dbname': 'dbt',
                        'schema': self.unique_schema(),
                    }
                },
                'target': 'my-target'
            }
        }

    @property
    def project_config(self):
        return {
            'config-version': 2,
            "models": {
                "schema": "dbt_test"
            },
        }

    def v1_schema(self):
        return f"{self.unique_schema()}_dbt_test"

    def v2_schema(self):
        return f"{self.unique_schema()}_custom"

    def xf_schema(self):
        return f"{self.unique_schema()}_test"

    def _list_schemas(self):
        with self.get_connection():
            return set(self.adapter.list_schemas(self.default_database))

    def assert_schemas_created(self, expected):
        assert self._list_schemas().intersection(expected) == expected

    def assert_schemas_not_created(self, expected):
        assert not self._list_schemas().intersection(expected)

    @use_profile('postgres')
    def test__postgres__custom_schema_with_prefix(self):
        schema = self.unique_schema()
        new_schemas = {self.v1_schema(), self.v2_schema(), self.xf_schema()}

        self.assert_schemas_not_created(new_schemas)

        self.run_sql_file("seed.sql")

        self.run_dbt(['ls'])
        self.assert_schemas_not_created(new_schemas)
        self.run_dbt(['compile'])
        self.assert_schemas_not_created(new_schemas)

        results = self.run_dbt()
        self.assertEqual(len(results), 3)
        self.assert_schemas_created(new_schemas)

        self.assertTablesEqual("seed", "view_1", schema, self.v1_schema())
        self.assertTablesEqual("seed", "view_2", schema, self.v2_schema())
        self.assertTablesEqual("agg", "view_3", schema, self.xf_schema())

class TestCustomSchemaWithCustomMacro(DBTIntegrationTest):
    def setUp(self):
        super().setUp()

        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v1_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v2_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.xf_schema())
        )

    @property
    def schema(self):
        return "custom_macro_024"

    @property
    def models(self):
        return "models"

    @property
    def profile_config(self):
        return {
            'test': {
                'outputs': {
                    'prod': {
                        'type': 'postgres',
                        'threads': 1,
                        'host': self.database_host,
                        'port': 5432,
                        'user': 'root',
                        'pass': 'password',
                        'dbname': 'dbt',
                        'schema': self.unique_schema(),
                    }
                },
                'target': 'prod'
            }
        }

    @property
    def project_config(self):
        return {
            'config-version': 2,
            'macro-paths': ['custom-macros'],
            'models': {
                'schema': 'dbt_test',
            }
        }

    def v1_schema(self):
        return f"dbt_test_{self.unique_schema()}_macro"

    def v2_schema(self):
        return f"custom_{self.unique_schema()}_macro"

    def xf_schema(self):
        return f"test_{self.unique_schema()}_macro"

    @use_profile('postgres')
    def test__postgres__custom_schema_from_macro(self):
        self.run_sql_file("seed.sql")

        results = self.run_dbt()
        self.assertEqual(len(results), 3)

        schema = self.unique_schema()

        self.assertTablesEqual("seed", "view_1", schema, self.v1_schema())
        self.assertTablesEqual("seed", "view_2", schema, self.v2_schema())
        self.assertTablesEqual("agg", "view_3", schema, self.xf_schema())

class TestCustomSchemaDispatchedPackageMacro(TestCustomSchemaWithCustomMacro):
    # test the same functionality as above, but this time,
    # dbt.generate_schema_name will dispatch to a default__ macro
    # from an installed package, per dispatch config search_order

    @property
    def project_config(self):
        return {
            "config-version": 2,
            "dispatch": [
                {
                    "macro_namespace": "dbt",
                    "search_order": ["test", "package_macro_overrides", "dbt"],
                }
            ],
            "models": {
                "schema": "dbt_test"
            },

        }

    @property
    def packages_config(self):
        return {
            'packages': [
                {
                    "local": "./package_macro_overrides",
                },
            ]
        }

    @use_profile('postgres')
    def test__postgres__custom_schema_from_macro(self):
        self.run_dbt(["deps"])
        super().test__postgres__custom_schema_from_macro

class TestCustomSchemaWithCustomMacroConfigs(TestCustomSchemaWithCustomMacro):

    @property
    def schema(self):
        return "custom_macro_cfg_024"

    @property
    def project_config(self):
        return {
            'config-version': 2,
            'macro-paths': ['custom-macros-configs'],
            'models': {
                'schema': 'dbt_test'
            },
        }

    @use_profile('postgres')
    def test__postgres__custom_schema_from_macro(self):
        self.run_sql_file("seed.sql")
        results = self.run_dbt()
        self.assertEqual(len(results), 3)

        schema = self.unique_schema()
        v1_schema = "dbt_test_{}_macro".format(schema)
        v2_schema = "custom_{}_macro".format(schema)
        xf_schema = "test_{}_macro".format(schema)

        self.assertTablesEqual("seed", "view_1", schema, v1_schema)
        self.assertTablesEqual("seed", "view_2", schema, v2_schema)
        self.assertTablesEqual("agg", "view_3", schema, xf_schema)

class TestCustomSchemaWithCustomMacroFromModelName(DBTIntegrationTest):
    def setUp(self):
        super().setUp()

        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v1_schema())
        )
        self._created_schemas.add(
            self._get_schema_fqn(self.default_database, self.v2_schema())
        )

    @property
    def schema(self):
        return "custom_macro_024"

    @property
    def models(self):
        return "dot-models"

    @property
    def profile_config(self):
        return {
            'test': {
                'outputs': {
                    'prod': {
                        'type': 'postgres',
                        'threads': 1,
                        'host': self.database_host,
                        'port': 5432,
                        'user': 'root',
                        'pass': 'password',
                        'dbname': 'dbt',
                        'schema': self.unique_schema(),
                    }
                },
                'target': 'prod'
            }
        }

    @property
    def project_config(self):
        return {
            'config-version': 2,
            'macro-paths': ['custom-macros-multischema'],
            'seed-paths': ['seed'],
            'seeds': {
                'quote_columns': False,
            },
            'models': {
                'schema': 'dbt_test',
            }
        }

    def v1_schema(self):
        return f"first_schema"

    def v2_schema(self):
        return f"second_schema"

    @use_profile('postgres')
    def test__postgres__custom_schema_from_macro_model_name(self):
        self.run_sql_file("seed.sql")
        default_schema = self.unique_schema()

        results = self.run_dbt(['seed'])
        self.assertEqual(len(results), 2)
        self.assertTableDoesExist("my_seed", self.v1_schema())
        self.assertTableDoesExist("my_agg", self.v2_schema())

        results = self.run_dbt()
        self.assertEqual(len(results), 3)

        self.assertTablesEqual("seed", "view_1", default_schema, self.v1_schema())
        self.assertTablesEqual("seed", "view_2", default_schema, self.v2_schema())
        self.assertTablesEqual("agg", "view_3", default_schema, default_schema)


text:
package com.vmware.vim25;

/**
* @author Steve Jin (http://www.doublecloud.org)
* @version 5.1
*/

@SuppressWarnings("all")
public class VirtualDeviceFileBackingInfo extends VirtualDeviceBackingInfo {
  public String fileName;
  public ManagedObjectReference datastore;
  public String backingObjectId;

  public String getFileName() {
    return this.fileName;
  }

  public ManagedObjectReference getDatastore() {
    return this.datastore;
  }

  public String getBackingObjectId() {
    return this.backingObjectId;
  }

  public void setFileName(String fileName) {
    this.fileName=fileName;
  }

  public void setDatastore(ManagedObjectReference datastore) {
    this.datastore=datastore;
  }

  public void setBackingObjectId(String backingObjectId) {
    this.backingObjectId=backingObjectId;
  }
}


text:
// This file is a part of DiabloSpeech and is under the MIT license.
// See the LICENSE file at the root of the project for more information.
using System;
using System.Security.Cryptography;
using System.Text;

namespace DiabloSpeech.Core
{
    public static class ProtectedString
    {
        static readonly Encoding Encoding = Encoding.Unicode;
        static readonly DataProtectionScope ProtectionScope = DataProtectionScope.CurrentUser;

        public static string DecryptBase64(string encoded64)
        {
            if (string.IsNullOrEmpty(encoded64))
                return string.Empty;

            // Decode base64 string.
            byte[] encrypted = Convert.FromBase64String(encoded64);

            // Decrypt data back to string.
            byte[] decrypted = ProtectedData.Unprotect(encrypted, null, ProtectionScope);
            return Encoding.GetString(decrypted).TrimEnd();
        }

        public static string EncryptBase64(string data)
        {
            if (string.IsNullOrEmpty(data))
                throw new ArgumentNullException(nameof(data));
            data = data + new string(' ', data.Length % 8);

            // Encypt bytes for current user.
            byte[] buffer = Encoding.GetBytes(data);
            byte[] encrypted = ProtectedData.Protect(buffer, null, ProtectionScope);

            // Return safe value as base64.
            return Convert.ToBase64String(encrypted);
        }
    }
}


text:
package memap.examples;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

import com.github.cliftonlabs.json_simple.JsonException;
import com.github.cliftonlabs.json_simple.JsonObject;
import com.github.cliftonlabs.json_simple.Jsoner;

import memap.components.CSVConsumer;
import memap.components.CSVCoupler;
import memap.components.CSVProducer;
import memap.components.CSVStorage;
import memap.components.CSVVolatileProducer;
import memap.components.prototypes.Connection;
import memap.components.prototypes.Consumer;
import memap.components.prototypes.Coupler;
import memap.components.prototypes.Producer;
import memap.components.prototypes.Storage;
import memap.controller.BuildingController;
import memap.controller.CSVBuildingController;
import memap.controller.OpcUaBuildingController;
import memap.controller.TopologyController;
import memap.helper.CO2Emission;
import memap.helper.ElectricityPrice;
import memap.helper.EnergyPrices;
import memap.helper.HeatPrice;
import memap.helper.MEMAPLogging;
import memap.helper.configurationOptions.OptHierarchy;
import memap.helper.configurationOptions.OptimizationCriteria;
import memap.helper.configurationOptions.Optimizer;
import memap.helper.configurationOptions.ToolUsage;
import memap.main.TopologyConfig;
import memap.messages.extension.NetworkType;

public abstract class ExampleLoader {
	public static TopologyController OpcUaExample(int nrStepsMPC) {

		TopologyController topologyController = new TopologyController("MemapExample", OptHierarchy.MEMAP,
				Optimizer.MILP, OptimizationCriteria.EUR, ToolUsage.PLANNING, MEMAPLogging.RESULTS_ONLY);
		TopologyConfig.getInstance().init(nrStepsMPC, 96, 7, 4880, 0);

		EnergyPrices.getInstance().init(new ElectricityPrice(9999, nrStepsMPC), new ElectricityPrice(0.285, nrStepsMPC),
				new ElectricityPrice(0.285, nrStepsMPC), new HeatPrice(0.285, nrStepsMPC), new CO2Emission(0.540, nrStepsMPC));

		try {

//			FileReader endpoint1 = new FileReader(("src/main/resources/examples/FortissBuilding1Endpoint.json"));
//			FileReader nodes1 = new FileReader(("src/main/resources/examples/FortissBuilding1Nodes.json"));
			FileReader endpoint1 = new FileReader(("src/main/java/resources/examples/FortissBuilding1Endpoint.json"));
			FileReader nodes1 = new FileReader(
					("src/main/java/resources/examples/FortissBuilding1Nodes_NewDatamodel.json"));

			JsonObject jsonEndpoint1 = (JsonObject) Jsoner.deserialize(endpoint1);
			JsonObject jsonNodes1 = (JsonObject) Jsoner.deserialize(nodes1);
			BuildingController sampleBuilding1 = new OpcUaBuildingController(topologyController, jsonEndpoint1,
					jsonNodes1, null);
			topologyController.attach(sampleBuilding1.getName(), sampleBuilding1);

		} catch (JsonException e1) {
			System.err.println("WARNING: Failed to read JSON config files. Building has not been initalised.");
			e1.printStackTrace();
		} catch (IllegalStateException e2) {
			System.err.println("WARNING: Failed to create Client. Building has not been initialised");
			e2.printStackTrace();
		} catch (FileNotFoundException e) {
			System.err.println("WARNING: File not found. Building has not been initialised");
			System.out.println(new File(".").getAbsolutePath());
			e.printStackTrace();
		}

		try {

//			FileReader endpoint2 = new FileReader(("src/main/resources/examples/FortissBuilding2Endpoint.json"));
//			FileReader nodes2 = new FileReader(("src/main/resources/examples/FortissBuilding2Nodes.json"));
			FileReader endpoint2 = new FileReader(("src/main/java/resources/examples/FortissBuilding2Endpoint.json"));
			FileReader nodes2 = new FileReader(
					("src/main/java/resources/examples/FortissBuilding2Nodes_NewDatamodel.json"));

			JsonObject jsonEndpoint2 = (JsonObject) Jsoner.deserialize(endpoint2);
			JsonObject jsonNodes2 = (JsonObject) Jsoner.deserialize(nodes2);
			BuildingController sampleBuilding2 = new OpcUaBuildingController(topologyController, jsonEndpoint2,
					jsonNodes2, null);
			topologyController.attach(sampleBuilding2.getName(), sampleBuilding2);
		} catch (JsonException e1) {
			System.err.println("WARNING: Failed to read JSON config files. Building has not been initalised.");
			e1.printStackTrace();
		} catch (IllegalStateException e2) {
			System.err.println("WARNING: Failed to create Client. Building has not been initialised");
			e2.printStackTrace();
		} catch (FileNotFoundException e) {
			System.err.println("WARNING: File not found. Building has not been initialised");
			System.out.println(new File(".").getAbsolutePath());
			e.printStackTrace();
		}

		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		return topologyController;
	}

	public static TopologyController CsvExample() {
		final int PORT_UNDEFINED = 0;
		int nrStepsMPC = 5;
		TopologyConfig.getInstance().init(nrStepsMPC, 96, 7, 0, 4880);

		EnergyPrices.getInstance().init(new ElectricityPrice(9999, nrStepsMPC), new ElectricityPrice(0.285, nrStepsMPC),
				new ElectricityPrice("ELECTRICITYPRICEEXAMPLE"), new HeatPrice(0.285, nrStepsMPC), new CO2Emission(0.540, nrStepsMPC));

		TopologyController topologyController = new TopologyController("MemapExample", OptHierarchy.BUILDING,
				Optimizer.MILP, OptimizationCriteria.EUR, ToolUsage.PLANNING, MEMAPLogging.RESULTS_ONLY);

		BuildingController building1 = new CSVBuildingController("Building1");
		Consumer consumer1 = new CSVConsumer("demand1", "CONSUMPTIONEXAMPLE1", 0);
		Producer producer1 = new CSVProducer("producer1", 0, 20.0, 0.89, NetworkType.HEAT, 0.0591, 0.202,
				PORT_UNDEFINED);
		building1.attach(producer1);
		building1.attach(consumer1);

		BuildingController building2 = new CSVBuildingController("Building2");
		Consumer consumer2 = new CSVConsumer("demand2", "CONSUMPTIONEXAMPLE2", 0);
		Storage battery2 = new CSVStorage("storage2", 30.0, 0.9, 0.9, 0.9, 0.95, 0.95, NetworkType.ELECTRICITY, 0.0001,
				0.0001, 0, 0);
		Producer producer2 = new CSVProducer("producer2", 0, 40.0, 0.89, NetworkType.HEAT, 0.0591, 0.202,
				PORT_UNDEFINED);
		building2.attach(producer2);
		building2.attach(battery2);
		building2.attach(consumer2);
		// TODO: Test connections with more buildings
		Connection connection = new Connection(building2.getName(), building1.getName(), 100, 0.01, 1000);
		building2.attach(connection);

		BuildingController building3 = new CSVBuildingController("Building3");
		Consumer consumer3 = new CSVConsumer("demand3", "CONSUMPTIONEXAMPLE3", 0);
		Producer pv3 = new CSVVolatileProducer("pv3", "", 0, 40.0, NetworkType.ELECTRICITY, 0.0001, 0, PORT_UNDEFINED);
		Coupler heatpump3 = new CSVCoupler("heatpump3", 0, 62.0, 2.5, -1, NetworkType.ELECTRICITY, NetworkType.HEAT,
				0.0591, 0.202, PORT_UNDEFINED);
		Storage thermalStorage3 = new CSVStorage("thermalStorage3", 300, 0.9, 180, 180, 0.9, 0.9, NetworkType.HEAT,
				0.0001, 0.0001, 0, PORT_UNDEFINED);
		building3.attach(pv3);
		building3.attach(heatpump3);
		building3.attach(thermalStorage3);
		building3.attach(consumer3);

		BuildingController building4 = new CSVBuildingController("Building4");
		Consumer consumer4 = new CSVConsumer("demand4", "CONSUMPTIONEXAMPLE4", 0);
		Coupler chp4 = new CSVCoupler("chp4", 0, 43, 0.61, 0.29, NetworkType.HEAT, NetworkType.ELECTRICITY, 0.0591,
				0.202, PORT_UNDEFINED);
		building4.attach(chp4);
		building4.attach(consumer4);

		BuildingController building5 = new CSVBuildingController("Building5");
		Consumer consumer5 = new CSVConsumer("demand5", "CONSUMPTIONEXAMPLE5", 0);
		Coupler chp5 = new CSVCoupler("chp5", 0, 43, 0.8, 0.4, NetworkType.HEAT, NetworkType.ELECTRICITY, 0.0591, 0.202,
				PORT_UNDEFINED);
		Producer solarThermic5 = new CSVVolatileProducer("solarThermic5", "FORECASTEXAMPLE", 0, 40, NetworkType.HEAT, 0,
				0, PORT_UNDEFINED);
		building5.attach(solarThermic5);
		building5.attach(chp5);
		building5.attach(consumer5);

		topologyController.attach(building1.getName(), building1);
		topologyController.attach(building2.getName(), building2);
		topologyController.attach(building3.getName(), building3);
		topologyController.attach(building4.getName(), building4);
		topologyController.attach(building5.getName(), building5);

		return topologyController;
	}

}


text:
// Part of <http://miracle.systems/p/h5.modbus> licensed under <MIT>

'use strict';

const Listener = require('../Listener');
const RemoteClient = require('../RemoteClient');

/** @type {?SerialPort} */
let SerialPort = null;

class SerialListener extends Listener
{
  /**
   * @param {SerialListenerOptions} [options]
   */
  constructor(options)
  {
    super();

    /**
     * @private
     * @type {function(this:SerialListener)}
     */
    this.onSerialOpen = this.onSerialOpen.bind(this);

    /**
     * @private
     * @type {function(this:SerialListener)}
     */
    this.onSerialClose = this.onSerialClose.bind(this);

    /**
     * @private
     * @type {function(this:SerialListener, Error)}
     */
    this.onSerialError = this.onSerialError.bind(this);

    /**
     * @private
     * @type {function(this:SerialListener)}
     */
    this.onSerialReadable = this.onSerialReadable.bind(this);

    if (!options)
    {
      options = {};
    }

    /**
     * @private
     * @type {SerialPortOptions}
     */
    this.serialPortOptions = Object.assign(
      {path: process.platform === 'win32' ? 'COM1' : '/dev/ttys0'},
      options.serialPortOptions,
      {autoOpen: false}
    );

    /**
     * @private
     * @type {?SerialPort}
     */
    this.serialPort = this.setUpSerialPort(options.serialPort);

    /**
     * @private
     * @type {boolean}
     */
    this.closeOnDestroy = options.closeOnDestroy !== false;

    /**
     * @private
     * @type {boolean}
     */
    this.suppressErrorsAfterDestroy = options.suppressErrorsAfterDestroy !== false;

    /**
     * @private
     * @type {?RemoteClient}
     */
    this.client = null;

    /**
     * @private
     * @type {?number}
     */
    this.setUpClientTimer = null;

    if (this.isOpen())
    {
      this.setUpClientTimer = setImmediate(this.setUpClient.bind(this));
    }
    else if (options.autoOpen !== false)
    {
      this.open();
    }
  }

  destroy()
  {
    if (this.setUpClientTimer !== null)
    {
      clearImmediate(this.setUpClientTimer);
      this.setUpClientTimer = null;
    }

    this.removeAllListeners();
    this.destroyClient();
    this.destroySerialPort();
  }

  /**
   * @returns {boolean}
   */
  isOpen()
  {
    return this.serialPort !== null && this.serialPort.isOpen;
  }

  /**
   * @returns {boolean}
   */
  isOpening()
  {
    return this.serialPort !== null && this.serialPort.opening;
  }

  open()
  {
    if (this.isOpen() || this.isOpening())
    {
      return;
    }

    if (this.serialPort === null)
    {
      this.serialPort = this.setUpSerialPort(null);
    }

    this.serialPort.open();
  }

  close()
  {
    if (this.serialPort !== null)
    {
      this.destroyClient();
      this.serialPort.close();
    }
  }

  /**
   * @private
   * @param {SerialPort} [serialPort]
   * @returns {SerialPort}
   */
  setUpSerialPort(serialPort)
  {
    if (!serialPort)
    {
      if (SerialPort === null)
      {
        SerialPort = require('serialport');
      }

      serialPort = new SerialPort(this.serialPortOptions.path, this.serialPortOptions);
    }

    serialPort.on('open', this.onSerialOpen);
    serialPort.on('close', this.onSerialClose);
    serialPort.on('error', this.onSerialError);
    serialPort.on('readable', this.onSerialReadable);

    return serialPort;
  }

  /**
   * @private
   */
  destroySerialPort()
  {
    const serialPort = this.serialPort;

    if (serialPort === null)
    {
      return;
    }

    serialPort.removeListener('open', this.onSerialOpen);
    serialPort.removeListener('close', this.onSerialClose);
    serialPort.removeListener('error', this.onSerialError);
    serialPort.removeListener('readable', this.onSerialReadable);

    if (this.suppressErrorsAfterDestroy)
    {
      serialPort.on('error', () => {});
    }

    if (this.closeOnDestroy)
    {
      serialPort.close();
    }

    this.serialPort = null;
  }

  /**
   * @private
   */
  onSerialOpen()
  {
    this.emit('open');
    this.setUpClient();
  }

  /**
   * @private
   */
  onSerialClose()
  {
    this.destroyClient();
    this.emit('close');
  }

  /**
   * @private
   * @param {Error} err
   */
  onSerialError(err)
  {
    this.emit('error', err);
  }

  /**
   * @private
   */
  onSerialReadable()
  {
    if (!this.client || !this.serialPort)
    {
      return;
    }

    while (true) // eslint-disable-line no-constant-condition
    {
      const data = this.serialPort.read();

      if (data === null)
      {
        break;
      }

      this.client.emit('data', data);
    }
  }

  /**
   * @private
   */
  setUpClient()
  {
    if (this.setUpClientTimer !== null)
    {
      clearImmediate(this.setUpClientTimer);
      this.setUpClientTimer = null;
    }

    this.destroyClient();

    this.client = new RemoteClient({
      path: this.serialPort.path
    });

    this.client.on('close', this.onClientClose.bind(this));
    this.client.on('write', this.onClientWrite.bind(this));

    this.emit('client', this.client);
  }

  /**
   * @private
   */
  destroyClient()
  {
    if (this.client !== null)
    {
      this.client.destroy();
    }
  }

  /**
   * @private
   * @param {Buffer} data
   */
  onClientWrite(data)
  {
    if (this.serialPort === null)
    {
      return;
    }

    try
    {
      this.serialPort.write(data);
    }
    catch (err)
    {
      this.client.emit('error', err);
    }
  }

  /**
   * @private
   */
  onClientClose()
  {
    this.client = null;
  }
}

module.exports = SerialListener;

/**
 * @typedef {Object} SerialListenerOptions
 * @property {SerialPort} [serialPort]
 * @property {SerialPortOptions} [serialPortOptions]
 * @property {boolean} [autoOpen=true]
 * @property {boolean} [closeOnDestroy=true]
 * @property {boolean} [suppressErrorsAfterDestroy=true]
 */

/**
 * @typedef {Object} SerialRemoteClientInfo
 * @property {string} path
 */


text:
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using SIPSorcery.Sys;

namespace SIPSorcery.Persistence
{
    public class EntityTypeConversionTable
    {
        private static Dictionary<string, DbType> m_conversionTable = new Dictionary<string, DbType>()
        {
            {"int", DbType.Int32},
            {"bit", DbType.Boolean},
            {"varchar", DbType.StringFixedLength},
            {"datetimeoffset", DbType.DateTimeOffset},
            {"datetime", DbType.DateTime},
            {"decimal", DbType.Decimal},
        };

        public static DbType LookupDbType(string entityType)
        {
            if(entityType.IsNullOrBlank())
            {
                throw new ArgumentNullException("entityType", "The entityType to lookup cannot be empty.");
            }

            if (entityType.Trim().StartsWith("varchar"))
            {
                return m_conversionTable["varchar"];
            }
            else
            {
                return m_conversionTable[entityType];
            }
        }
    }
}


text:
<?php

namespace Sylius\Behat\Page\Shop\Taxon;

/**
 * @author Anna Walasek <anna.walasek@lakion.com>
 */
interface ShowPageInterface
{
    /**
     * @param string $productName
     *
     * @return bool
     */
    public function isProductInList($productName);

    /**
     * @return bool
     */
    public function isEmpty();
}


text:
package com.smartdevicelink.proxy.rpc;

import android.support.annotation.NonNull;

import com.smartdevicelink.proxy.RPCStruct;

import java.util.Hashtable;
/**
 * Types of screen touch events available in screen area.
 *
 *
Parameter List

 *

 *

 * 			Name
 * 			Type
 * 			Description
 *                 Reg.
 *               Notes
 * 			SmartDeviceLink Version
 *

 *

 * 			pressAvailable
 * 			Boolean
 *
 *                 Y
 *
 * 			SmartDeviceLink 3.0
 *

 *

 * 			multiTouchAvailable
 * 			Boolean
 *
 *                 Y
 *
 * 			SmartDeviceLink 3.0
 *

 *

 * 			doublePressAvailable
 * 			Boolean
 *
 *                 Y
 *
 * 			SmartDeviceLink 3.0
 *

 *

 *
 */
public class TouchEventCapabilities extends RPCStruct {
    public static final String KEY_PRESS_AVAILABLE = "pressAvailable";
    public static final String KEY_MULTI_TOUCH_AVAILABLE = "multiTouchAvailable";
    public static final String KEY_DOUBLE_PRESS_AVAILABLE = "doublePressAvailable";
    public TouchEventCapabilities() {}

    public TouchEventCapabilities(Hashtable<String, Object> hash) {
        super(hash);
    }

	/**
	 * Types of screen touch events available in screen area.
	 * @param pressAvailable if press is available
	 * @param multiTouchAvailable if multi touch is available
	 * @param doublePressAvailable if double press is available
	 */
	public TouchEventCapabilities(@NonNull Boolean pressAvailable, @NonNull Boolean multiTouchAvailable, @NonNull Boolean doublePressAvailable){
		this();
		setPressAvailable(pressAvailable);
		setMultiTouchAvailable(multiTouchAvailable);
		setDoublePressAvailable(doublePressAvailable);
	}

    public void setPressAvailable(@NonNull Boolean pressAvailable) {
        setValue(KEY_PRESS_AVAILABLE, pressAvailable);
    }

    public Boolean getPressAvailable() {
        return getBoolean(KEY_PRESS_AVAILABLE);
    }

    public void setMultiTouchAvailable(@NonNull Boolean multiTouchAvailable) {
        setValue(KEY_MULTI_TOUCH_AVAILABLE, multiTouchAvailable);
    }

    public Boolean getMultiTouchAvailable() {
        return getBoolean(KEY_MULTI_TOUCH_AVAILABLE);
    }

    public void setDoublePressAvailable(@NonNull Boolean doublePressAvailable) {
        setValue(KEY_DOUBLE_PRESS_AVAILABLE, doublePressAvailable);
    }

    public Boolean getDoublePressAvailable() {
        return getBoolean(KEY_DOUBLE_PRESS_AVAILABLE);
    }
}


text:
package translator

import (
	"github.com/Shopify/go-lua"
	"github.com/fsouza/go-dockerclient"
)

func checkBoolean(l *lua.State, index int) bool {
	lua.CheckType(l, index, lua.TypeBoolean)
	return l.ToBoolean(index)
}

func checkStringArray(l *lua.State, index int) []string {
	lua.CheckType(l, index, lua.TypeTable)

	var items []string

	l.PushNil()
	for l.Next(-2) {
		items = append(items, lua.CheckString(l, -1))
		l.Pop(1)
	}

	return items
}

func checkStringMap(l *lua.State, index int) map[string]string {
	lua.CheckType(l, index, lua.TypeTable)
	items := make(map[string]string)

	l.PushNil()
	for l.Next(-2) {
		key := lua.CheckString(l, -2)
		val := lua.CheckString(l, -1)
		items[key] = val
		l.Pop(1)
	}

	return items
}

func parseExposedPorts(l *lua.State, index int) map[docker.Port]struct{} {
	items := map[docker.Port]struct{}{}

	for _, el := range checkStringArray(l, index) {
		items[docker.Port(el)] = struct{}{}
	}

	return items
}

func checkStringSet(l *lua.State, index int) map[string]struct{} {
	items := map[string]struct{}{}
	for _, el := range checkStringArray(l, index) {
		items[el] = struct{}{}
	}
	return items
}


text:
namespace supersonic {

// Base class for deserializers, which are reading data from byte buffers.
class Deserializer {
 public:
  Deserializer() {}
  virtual ~Deserializer() {}

  // Deserializes data from given byte buffer. Returns a pointer to buffer
  // containing deserialized data and row count.
  virtual FailureOr<pair<VariantConstPointer, rowcount_t> >
      Deserialize(const void* byte_buffer,
                  const ByteBufferHeader& byte_buffer_header) = 0;
 private:
  DISALLOW_COPY_AND_ASSIGN(Deserializer);
};

}  // namespace supersonic

#endif  // SUPERSONIC_CONTRIB_STORAGE_BASE_DESERIALIZER_H_


text:
def size(node):
	if not node:
		return 0
	return node.cout

def rank(key, root):
	if not root:
		return 0
	if key < root.val:
		return rank(root.left)
	elif key > root.val:
		return rank(root.left) + 1 + rank(root.right)
	else:
		return size(root.left)


text:
import { DeviceType } from './device-type';

let instance;

const type = 'action.devices.types.STREAMING_STICK'

class StreamingStick extends DeviceType {
  constructor() {
    super()
    this.valuesArray = [{
      nicknames: ['Media center streaming stick'],
      roomHint: 'Living Room',
    }];
  }

  static createDevice() {
    if (!instance) {
      instance = new StreamingStick()
    }
    const element = instance.valuesArray.shift();

    return {
      id: instance.genUuid(),
      type,
      traits: [
        'action.devices.traits.AppSelector',
        'action.devices.traits.MediaState',
        'action.devices.traits.TransportControl',
        'action.devices.traits.Volume',
      ],
      defaultNames: ['Smart Streaming Stick'],
      name: 'Smart Streaming Stick',
      nicknames: instance.getNicknames(element),
      roomHint: instance.getRoomHint(element),
      attributes: {
        transportControlSupportedCommands: [
          'NEXT', 'PREVIOUS', 'PAUSE', 'STOP', 'RESUME',
        ],
        availableApplications: [{
          key: 'youtube',
          names: [{
            name_synonym: ['youtube', 'Youtube_en'],
            lang: 'en',
          }],
        }],
        volumeMaxLevel: 11,
        volumeCanMuteAndUnmute: true,
        supportActivityState: true,
        supportPlaybackState: true,
      },
      willReportState: true,
      states: {
        online: true,
        currentVolume: 11,
        isMuted: false,
        currentApplication: 'youtube',
        activityState: 'ACTIVE',
        playbackState: 'STOPPED',
      },
      hwVersion: '1.0.0',
      swVersion: '2.0.0',
      model: 'L',
      manufacturer: 'L',
    };
  }
}

window.deviceTypes.push({
  type,
  identifier: '_addStreamingStick',
  icon: 'image:straighten',
  label: 'Streaming Stick',
  function: (app) => {
    app._createDevice(StreamingStick.createDevice());
  },
})


text:
<title>removeEntryNotice</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

removeEntryNotice

Usage

myhStateC.removeEntryNotice(listener)

Parameters

listener Listener object registered to receive entry notices.

Returns

Nothing

Description

This is a new method of FStEng v1.5. It removes the listener from the list of those notified when the state becomes active.


text:
/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */

package test.fixtures.basic_swift_bean;

import com.facebook.thrift.client.*;
import java.util.*;

public class LegacyServiceBlockingReactiveWrapper
    implements LegacyService.Reactive {
    private final LegacyService _delegate;

    public LegacyServiceBlockingReactiveWrapper(LegacyService _delegate) {

        this._delegate = _delegate;
    }

    @java.lang.Override
    public void dispose() {
        _delegate.close();
    }

    @java.lang.Override
    public reactor.core.publisher.Mono<Map<String, List<Integer>>> getPoints(final Set<String> key, final long legacyStuff) {
        reactor.core.publisher.Mono<Map<String, List<Integer>>> _m =  reactor.core.publisher.Mono.fromSupplier(() -> {
                try {
                    return _delegate.getPoints(key, legacyStuff);
                } catch (Throwable _e) {
                    throw reactor.core.Exceptions.propagate(_e);
                }
            });

        if (!com.facebook.thrift.util.resources.RpcResources.isForceExecutionOffEventLoop()) {
            _m = _m.subscribeOn(com.facebook.thrift.util.resources.RpcResources.getOffLoopScheduler());
        }

        return _m;
    }

}


text:
require 'spec_helper'
require 'volt/models'

describe Volt::Persistors::Store do
  it 'should tell the persistor when the model has changed' do
    persistor = double('volt/persistor')
    persistor_instance = double('volt/persistor instance')
    expect(persistor_instance).to receive(:loaded)
    expect(persistor).to receive(:new).and_return(persistor_instance)

    @model = Volt::Model.new({}, persistor: persistor)

    expect(persistor_instance).to receive(:changed)

    @model._attr = 'yes'
  end

  it 'should tell the persistor when something is added to an array model' do
    persistor = double('volt/persistor')
    persistor_instance = double('volt/persistor instance')
    expect(persistor_instance).to receive(:loaded)
    expect(persistor).to receive(:new).and_return(persistor_instance)
    expect(persistor_instance).to receive(:async?).and_return(false)

    @model = Volt::ArrayModel.new([1, 2, 3], persistor: persistor)

    expect(persistor_instance).to receive(:added).with(4, 3)

    @model << 4
  end

  it 'passes removed() to changed() by default' do
    model     = Volt::Model.new(abc: 123)
    persistor = Volt::Persistors::Store.new(model)
    expect(persistor.removed(:abc)).to eq(persistor.changed(:abc))
    model._abc = 456
    expect(persistor.removed(:abc)).to eq(persistor.changed(:abc))
  end

  unless RUBY_PLATFORM == 'opal'
    before do
      model = store._nesters.create(name: 'One').sync
      model._subone = {name: 'Two'}
    end

    it 'should reload a model with nested hash models' do
      model2 = store._nesters.first.sync

      expect(model2.to_h.without(:id, :subone)).to eq(name: 'One')
      expect(model2._subone.to_h.without(:id)).to eq(name: 'Two')
    end

    it 'should reload nested hash models with the same parent persistor' do
      model = store._nesters.first.sync
      expect(model.persistor).to eq(model._subone.persistor)
    end
  end

  unless RUBY_PLATFORM == 'opal'
    it 'should sync properties on the root' do
      store._name = 'Jim'
      store._name.then do |name|
        expect(name).to eq('Jim')
      end
    end
  end
end


text:
    getSiteUrl = function () {
      return getSetting('siteUrl', Meteor.absoluteUrl());
    };

    getSetting = function(setting, defaultValue){
      var settings = Settings.find().fetch()[0];
      if(settings && (typeof settings[setting] !== 'undefined')){
        return settings[setting];
      }else{
        return typeof defaultValue === 'undefined' ? '' : defaultValue;
      }
      return defaultValue;
    };

    capitalizeFirst = function(string) {
      return string.charAt(0).toUpperCase() + string.slice(1);
    };

    capitalize = function(words) {
        var parts = words.toString().split(' ');
        var caps = _.map(parts, function (w) {
          return w.substr(0, 1).toUpperCase() + w.substr(1);
        });
        return caps.join(' '); //str.substr(0, 1).toUpperCase() + str.substr(1);
    };

    String.prototype.replaceAll = function(target, replacement) {
      return this.split(target).join(replacement);
    };

    randomStr = function(length)
    {
        var text = "";
        var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

        for( var i=0; i < length; i++ )
            text += possible.charAt(Math.floor(Math.random() * possible.length));

        return text;
    };

    appendToFileName = function(filename, str) {
        var parts = filename.split('.');
        var ext = parts.pop();
        return parts.join('.') + str + '.' + ext;
    };

    currentPath = function () {
      var c=window.location.pathname;
      var b=c.slice(0,-1);
      var a=c.slice(-1);
      if(b=="") {
        return"/"
      } else {
        if(a=="/") {
          return b;
        } else {
          return c;
        }
      }

    };

    currentURL = function () {
      return window.location.host;

    };

    getIndexOf = function (arr, itemId) {
      for(var i = 0, len = arr.length; i < len; i++) {
          if (arr[i]._id === itemId) return i;
      }
      return -1;
    };

    isTouchDevice = function() {
      if (('ontouchstart' in window) ||
          (navigator.maxTouchPoints > 0) ||
          (navigator.msMaxTouchPoints > 0)) {
        return true;
      } else {
        return false;
      }
    };


text:
#include "minunit.h"
#include "stdio.h"
#include "mbedtls/x509_crt.h"
#include "mbedtls/error.h"
char *test_SSL_verify_cert()
{

    mbedtls_x509_crt crt;
    memset( &crt, 0, sizeof crt );

    mbedtls_x509_crt ca_crt;
    memset( &ca_crt, 0, sizeof ca_crt );

    mbedtls_x509_crl crl;
    memset( &crl, 0, sizeof crl );

    int ret = 0;

    ret =mbedtls_x509_crt_parse_file( &crt, "tests/ca/certs/m2-cert.pem" );

    mu_assert(ret == 0, "failed to parse cert m2-cert.pem");

    ret =mbedtls_x509_crt_parse_file( &ca_crt, "tests/ca/none.pem" );

    mu_assert(ret != 0, "failed to fail on non-existent pem none.pem");

    ret =mbedtls_x509_crt_parse_file( &ca_crt, "tests/ca/cacert.pem" );

    mu_assert(ret == 0, "failed to parse cert cacert.pem");

    ret =mbedtls_x509_crl_parse_file( &crl, "tests/ca/crl.pem" );

    mu_assert(ret == 0, "failed to parse cert crl.pem");

    /*
     * Validate the cert.  Since these certs are only valid within a certain time period, this test
     * will fail when the current time is outside this period.  To avoid false failures (eg. when
     * building/testing this version of the software in the distant future), adjust the expected
     * test outcome accordingly.  However, log the failure to stderr so that the maintainer can
     * detect the expiry of the cert, and generate/commit a new one from time to time.
     */
    uint32_t flags = 0;
    ret =mbedtls_x509_crt_verify( &crt, &ca_crt, NULL, NULL, &flags, NULL, NULL);
    if ( ret ) {
	char buf[1024];
	buf[0] = 0;
	mbedtls_strerror( ret, buf, sizeof buf );
	fprintf( stderr, "*** x509_crt_verify of m2-cert.pem: %d: %s\n", ret, buf );
    }
    int valid_from = mbedtls_x509_time_is_past( &crt.valid_from );
    int valid_to   = mbedtls_x509_time_is_past( &crt.valid_to );

    int expected = 0;
    if ( valid_from == MBEDTLS_X509_BADCERT_EXPIRED && valid_to == MBEDTLS_X509_BADCERT_EXPIRED ) {
	/*
	 * This cert hasn't yet become active, or has already expired; expect
	 * X509 cert failure (-0x2700)
	 */
	fprintf( stderr, "*** x509_crt_verify WILL FAIL because current data is outside: valid_from '%d/%d/%d %d:%d:%d': %d, valid_to '%d/%d/%d %d:%d:%d': %d\n",
	       crt.valid_from.year, crt.valid_from.mon, crt.valid_from.day, crt.valid_from.hour, crt.valid_from.min, crt.valid_from.sec, valid_from,
	       crt.valid_to  .year, crt.valid_to  .mon, crt.valid_to  .day, crt.valid_to  .hour, crt.valid_to  .min, crt.valid_to  .sec, valid_to );
	fprintf( stderr, "*** If this is the currently supported version, generate and commit a new tests/ca/m2-cert.pem with valid dates\n" );
	expected = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED;
    }
    mu_assert(ret == expected, "failed to verify cert m2-cert.pem");

    mbedtls_x509_crt_free( &crt );
    mbedtls_x509_crt_free( &ca_crt );
    mbedtls_x509_crl_free( &crl );

    return NULL;
}

char * all_tests() {
    mu_suite_start();

    mu_run_test(test_SSL_verify_cert);

    return NULL;
}

RUN_TESTS(all_tests);


text:
title: Observable.OfType<TResult>()
---
# Observable.OfType\<TResult\> Method

Filters the elements of an observable sequence based on the specified type.

**Namespace:**  [System.Reactive.Linq](System.Reactive.Linq/System.Reactive.Linq)
**Assembly:**  System.Reactive (in System.Reactive.dll)

## Syntax

```vb
'Declaration
<ExtensionAttribute> _
Public Shared Function OfType(Of TResult) ( _
    source As IObservable(Of Object) _
) As IObservable(Of TResult)
```

```vb
'Usage
Dim source As IObservable(Of Object)
Dim returnValue As IObservable(Of TResult)

returnValue = source.OfType()
```

```csharp
public static IObservable<TResult> OfType<TResult>(
    this IObservable<Object> source
)
```

```c++
[ExtensionAttribute]
public:
generic<typename TResult>
static IObservable<TResult>^ OfType(
    IObservable<Object^>^ source
)
```

```fsharp
static member OfType :
        source:IObservable<Object> -> IObservable<'TResult>
```

```javascript
JScript does not support generic types and methods.
```

#### Type Parameters

- TResult
  The type of result.

#### Parameters

- source
  Type: [System.IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<[Object](https://msdn.microsoft.com/en-us/library/e5kfa45b)\>
  The source sequence.

#### Return Value

Type: [System.IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<TResult\>
An observable sequence that contains elements from the input sequence of type TResult.

#### Usage Note

In Visual Basic and C\#, you can call this method as an instance method on any object of type [IObservable](https://msdn.microsoft.com/en-us/library/Dd990377)\<[Object](https://msdn.microsoft.com/en-us/library/e5kfa45b)\>. When you use instance method syntax to call this method, omit the first parameter. For more information, see [](https://msdn.microsoft.com/en-us/library/Bb384936) or [](https://msdn.microsoft.com/en-us/library/Bb383977).

## See Also

#### Reference

[Observable Class](Observable/Observable)

[System.Reactive.Linq Namespace](System.Reactive.Linq/System.Reactive.Linq)


text:
<?php

  use Kironuniversity\Curriculum\Classes\Curriculum;

  Route::get('updatecurriculumforstudent/{student}/{studyprogram}', function($studentID,$studyProgramID){
    $curriculum = new Curriculum($studentID);
    $curriculum->setStudyProgram($studyProgramID);
    $curriculum->buildCurriculum();
    DB::connection('plan')->unprepared('SELECT refreshallmaterializedviews();');
    return 'ok';
  });

 ?>


text:
using Microsoft.Extensions.Logging;
using System.Linq;
using NTumbleBit.ClassicTumbler.CLI;
using NTumbleBit.Configuration;
using NTumbleBit.Tor;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Diagnostics;
using NTumbleBit.Logging;

namespace NTumbleBit.ClassicTumbler.Client.ConnectionSettings
{
	public class TorConnectionSettings : ConnectionSettingsBase, ITorConnectionSettings
	{
		public static TorConnectionSettings ParseConnectionSettings(string prefix, TextFileConfiguration config)
		{
			TorConnectionSettings settings = new TorConnectionSettings();
			settings.Server = config.GetOrDefault<IPEndPoint>(prefix + ".server", new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9051));
			settings.Password = config.GetOrDefault<string>(prefix + ".password", null);
			settings.CookieFile = config.GetOrDefault<string>(prefix + ".cookiefile", null);
			settings.VirtualPort = config.GetOrDefault<int>(prefix + ".virtualport", 80);
			return settings;
		}
		public enum ConnectionTest
		{
			AuthError,
			Success,
			SocketError
		}
		public IPEndPoint Server
		{
			get; set;
		}

		public string Password
		{
			get; set;
		}

		public string CookieFile
		{
			get; set;
		}

		public int VirtualPort
		{
			get; set;
		}

		internal IPEndPoint SocksEndpoint
		{
			get; set;
		}

		public override HttpMessageHandler CreateHttpHandler()
		{
			throw new NotSupportedException();
		}

		public void AutoDetectCookieFile()
		{
			FileInfo cookie = null;
			if(!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				cookie = new FileInfo("/var/lib/tor/control_auth_cookie");
				cookie = cookie.Exists ? cookie : new FileInfo("/var/run/tor/control.authcookie");

				var home = Environment.GetEnvironmentVariable("HOME");
				if(!string.IsNullOrEmpty(home))
				{
					cookie = cookie.Exists ? cookie : new FileInfo(Path.Combine(home, ".tor", "control_auth_cookie"));
					cookie = cookie.Exists ? cookie : new FileInfo(Path.Combine(home, ".tor", "control.authcookie"));
				}
			}
			else
			{
				var localAppData = Environment.GetEnvironmentVariable("APPDATA");
				cookie = new FileInfo(Path.Combine(localAppData, "tor", "control_auth_cookie"));
			}

			if(!cookie.Exists)
				throw new ConfigException("NTumbleBit could not find any tor control cookie");
			CookieFile = cookie.FullName;
			try
			{
				File.ReadAllBytes(CookieFile);
			}
			catch(Exception ex)
			{
				throw new ConfigException("Error while reading tor cookie file " + ex.Message);
			}
		}

		async Task<ConnectionTest> TryConnectAsync()
		{
			using(var tor = CreateTorClient2())
			{
				try
				{
					await tor.ConnectAsync().ConfigureAwait(false);
				}
				catch { return ConnectionTest.SocketError; }

				if(!await tor.AuthenticateAsync().ConfigureAwait(false))
					return ConnectionTest.AuthError;
				if(SocksEndpoint == null)
				{
					var endpoints = await tor.GetSocksListenersAsync().ConfigureAwait(false);
					SocksEndpoint = endpoints.FirstOrDefault();
					if(SocksEndpoint == null)
						throw new TorException("Tor has no socks listener", "");
				}
				return ConnectionTest.Success;
			}
		}

		internal TorClient CreateTorClient2()
		{
			if(string.IsNullOrEmpty(Password) && string.IsNullOrEmpty(CookieFile))
			{
				return new TorClient(Server.Address.ToString(), Server.Port);
			}
			if(!string.IsNullOrEmpty(Password))
			{
				return new TorClient(Server.Address.ToString(), Server.Port, Password);
			}
			if(!string.IsNullOrEmpty(CookieFile))
			{
				return new TorClient(Server.Address.ToString(), Server.Port, new FileInfo(CookieFile));
			}
			else
				throw new ConfigException("Invalid Tor configuration");
		}

		public async Task<IDisposable> SetupAsync(ClientInteraction interaction, string torPath)
		{
			var autoConfig = string.IsNullOrEmpty(Password) && String.IsNullOrEmpty(CookieFile) && Server.Address.Equals(IPAddress.Parse("127.0.0.1"));
			var connectResult = await TryConnectAsync().ConfigureAwait(false);
			if(connectResult == TorConnectionSettings.ConnectionTest.SocketError)
			{
				if(torPath != null && autoConfig)
				{
					var args = $"-controlport {Server.Port} -cookieauthentication 1";
					await interaction.AskConnectToTorAsync(torPath, args).ConfigureAwait(false);
					try
					{
						var processInfo = new ProcessStartInfo(torPath)
						{
							Arguments = args,
							UseShellExecute = false,
							CreateNoWindow = true,
							RedirectStandardOutput = false
						};
						var process = new ProcessDisposable(Process.Start(processInfo));
						try
						{
							await SetupAsync(interaction, null).ConfigureAwait(false);
						}
						catch
						{
							process.Dispose();
							throw;
						}
						return process;
					}
					catch(Exception ex)
					{
						Logs.Configuration.LogError($"Failed to start Tor, please verify your configuration settings \"torpath\": {ex.Message}");
					}
				}
				throw new ConfigException("Unable to connect to tor control port");
			}
			else if(connectResult == TorConnectionSettings.ConnectionTest.Success)
				return NullDisposable.Instance;
			else if(!autoConfig && connectResult == TorConnectionSettings.ConnectionTest.AuthError)
				throw new ConfigException("Unable to authenticate tor control port");

			if(autoConfig)
				AutoDetectCookieFile();
			connectResult = await TryConnectAsync().ConfigureAwait(false);
			if(connectResult != TorConnectionSettings.ConnectionTest.Success)
				throw new ConfigException("Unable to authenticate tor control port");
			return NullDisposable.Instance;
		}
	}
}


text:
URI parser and builder with semantic API

Name	uri

Version	0.2.2

Size	3 KB / 1 KB (gzipped)

Environment	Node, Browser

## Features

- URI parsing
- URI builder
- RFC 3986 compliant
- Full and partial URI support
- Automatic query mapping values
- Support for special characters decoding

## Installation

#### Node.js
```bash
npm install lil-uri
```

#### Browser
Via [Bower](http://bower.io)
```bash
bower install lil-uri
```
Via [Component](https://github.com/componentjs/component)
```bash
component install lil-js/uri
```
Or loading the script remotely
```html
<script src="//cdn.rawgit.com/lil-js/uri/0.2.2/uri.js"></script>
```

### Environments

Cross-browser support guaranteed running tests in [BrowserStack](http://browserstack.com/)

- Node.js
- Chrome >= 5
- Firefox >= 3
- Safari >= 5
- Opera >= 10
- IE >= 9

### Usage

You could fetch de module via `require()` if it's available.
Otherwise, global fallback will be used, exposed via `lil.uri`
```js
var uri = require('lil-uri')
```

##### Parser
```js
var url = uri('http://user:pass@example.com:8080/bar/foo.xml?foo=bar&hello=world&#hash=1')
url.protocol() // -> http
url.host() // -> example.com:8080
url.hostname() // -> example.com
url.port() // -> 8080
url.auth() // -> { user: 'user', password: 'pass' }
url.user() // -> user
url.password() // -> pass
url.path() // -> /bar/foo.xml
url.search() // -> foo=bar&hello=world
url.query() // -> { foo: 'bar', hello: 'world' }
url.hash() // -> hash=1
```

##### Builder
```js
uri()
  .protocol('https')
  .host('example.com')
  .port('8080')
  .auth('user:pass')
  .path('/bar/foo.xml')
  .query({ foo: 'bar', hello: 'world' })
  .hash('hash=1')
  .build() // -> http://@example.com:8080/bar/foo.xml?foo=bar&hello=world&#frament=1
```

## API

#### uri([ uri ])

#### uri#protocol([ protocol ])

#### uri#host([ host ])

#### uri#hostname([ hostname ])

#### uri#port([ port ])

#### uri#auth([ auth ])

#### uri#user([ user ])

#### uri#password([ password ])

#### uri#path([ path ])

#### uri#search([ search ])

#### uri#query([ query ])

#### uri#hash([ fragment ])

#### uri#build()

#### uri#parse(uri)

#### uri.isURL(str)

#### uri.is(url)

#### uri.URI(uri)

#### uri.VERSION

## Contributing

Wanna help? Cool! It will be appreciated :)

You must add new test cases for any new feature or refactor you do,
always following the same design/code patterns that already exist

### Development

Only [node.js](http://nodejs.org) is required for development

Clone the repository
```bash
$ git clone https://github.com/lil-js/uri.git && cd uri
```

Install dependencies
```bash
$ npm install
```

Generate browser bundle source
```bash
$ make browser
```

Run tests
```bash
$ make test
```

## License

[MIT](http://opensource.org/licenses/MIT) © Tomas Aparicio

[travis]: http://travis-ci.org/lil-js/uri


text:
(function() {
    'use strict';

    angular.module('JHipsterRegistryApp')
        .controller('HealthModalController', HealthModalController);

    HealthModalController.$inject = ['$uibModalInstance', 'currentHealth', 'baseName', 'subSystemName'];

    function HealthModalController ($uibModalInstance, currentHealth, baseName, subSystemName) {
        var vm = this;

        vm.cancel = cancel;
        vm.currentHealth = currentHealth;
        vm.baseName = baseName;
        vm.subSystemName = subSystemName;

        function cancel() {
            $uibModalInstance.dismiss('cancel');
        }
    }
})();


text:
from . import controllers
from . import models


text:
package org.jsflot.xydata;

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

public class XYDataSetCollection {
	private List<XYDataList> dataCollection;

	public XYDataSetCollection() {
		dataCollection = new ArrayList<XYDataList>();
	}

	public boolean addDataList(XYDataList list) {
		return dataCollection.add(list);
	}

	public boolean removeDataList(XYDataList list) {
		return dataCollection.remove(list);
	}

	public XYDataList removeDataList(int index) {
		return dataCollection.remove(index);
	}

	public void clearDataCollection() {
		this.dataCollection.clear();
	}

	public List<XYDataList> getDataList() {
		return dataCollection;
	}

	public XYDataList get(int index) {
		return dataCollection.get(index);
	}

	public int size() {
		return dataCollection.size();
	}

	public int indexOf(XYDataList list) {
		return dataCollection.indexOf(list);
	}
}


text:
tests: tests.o ubasic.o tokenizer.o
use-ubasic: use-ubasic.o ubasic.o tokenizer.o
clean:
	rm *.o tests use-ubasic


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;

namespace Octokit
{
    [SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces",
        Justification = "People can use fully qualified names if they want to use both.")]
    [DebuggerDisplay("{DebuggerDisplay,nq}")]
    public class Deployment
    {
        public Deployment() { }

        public Deployment(int id, string sha, string url, User creator, IReadOnlyDictionary<string, string> payload, DateTimeOffset createdAt, DateTimeOffset updatedAt, string description, string statusesUrl, bool transientEnvironment, bool productionEnvironment)
        {
            Id = id;
            Sha = sha;
            Url = url;
            Creator = creator;
            Payload = payload;
            CreatedAt = createdAt;
            UpdatedAt = updatedAt;
            Description = description;
            StatusesUrl = statusesUrl;
            TransientEnvironment = transientEnvironment;
            ProductionEnvironment = productionEnvironment;
        }

        /// <summary>
        /// Id of this deployment.
        /// </summary>
        public int Id { get; protected set; }

        /// <summary>
        ///
        /// </summary>
        public string Sha { get; protected set; }

        /// <summary>
        /// The API URL for this deployment.
        /// </summary>
        public string Url { get; protected set; }

        /// <summary>
        /// The <seealso cref="User"/> that created the deployment.
        /// </summary>
        public User Creator { get; protected set; }

        /// <summary>
        /// JSON payload with extra information about the deployment.
        /// </summary>
        public IReadOnlyDictionary<string, string> Payload { get; protected set; }

        /// <summary>
        /// Date and time that the deployment was created.
        /// </summary>
        public DateTimeOffset CreatedAt { get; protected set; }

        /// <summary>
        /// Date and time that the deployment was updated.
        /// </summary>
        public DateTimeOffset UpdatedAt { get; protected set; }

        /// <summary>
        /// A short description of the deployment.
        /// </summary>
        public string Description { get; protected set; }

        /// <summary>
        /// The API URL for the <seealso cref="DeploymentStatus"/>es of this deployment.
        /// </summary>
        public string StatusesUrl { get; protected set; }

        /// <summary>
        /// Indicates if the environment is specific to a deployment and will no longer exist at some point in the future.
        /// </summary>
        public bool TransientEnvironment { get; protected set; }

        /// <summary>
        /// Indicates if the environment is one with which end users directly interact.
        /// </summary>
        public bool ProductionEnvironment { get; protected set; }

        internal string DebuggerDisplay
        {
            get
            {
                return string.Format(CultureInfo.InvariantCulture, "CreatedAt: {0}", CreatedAt);
            }
        }
    }
}


text:
package cache

import (
	"context"
	"time"
)

// A LoaderWithTTLFunc is a function for loading entries from a cache, also
// returning an expiration time.
type LoaderWithTTLFunc func(ctx context.Context, key string) (interface{}, time.Time, error)

// A LoaderFunc is a function for loading entries from a cache.
type LoaderFunc func(ctx context.Context, key string) (interface{}, error)

// Cache is an interface for caches.
type Cache interface {
	// Put puts a new item in the cache with the default TTL.
	Put(key string, value interface{})

	// PutWithTTL puts a new item in the cache with a specific TTL.
	PutWithTTL(key string, value interface{}, ttl time.Duration)

	// Get returns the value associated with the key, optionally
	// loading it if it does not exist or has expired.
	// NB(mmihic): We pass the loader as an argument rather than
	// making it a property of the cache to support access specific
	// loading arguments which might not be bundled into the key.
	Get(ctx context.Context, key string, loader LoaderFunc) (interface{}, error)

	// GetWithTTL returns the value associated with the key, optionally
	// loading it if it does not exist or has expired, and allowing the
	// loader to return a TTL for the resulting value, overriding the
	// default TTL associated with the cache.
	GetWithTTL(ctx context.Context, key string, loader LoaderWithTTLFunc) (interface{}, error)
}


text:
"""@package src.clm.views.user.public_ip

@alldecoratedby{src.clm.utils.decorators.user_log}
"""

from clm.utils.decorators import user_log, cm_request

@user_log(log=False, pack=False)
@cm_request
def get_list(cm_response, **data):
    """
    Returns list of caller's public IPs.

    @clmview_user
    @cm_request_transparent{user.public_ip.get_list()}
    """
    return cm_response

@user_log(log=True, pack=False)
@cm_request
def request(cm_response, **data):
    """
    Sends request to grant new public IP for caller. If caller's quota allowes,
    user will obtain new public IP.

    @clmview_user
    @cm_request_transparent{user.public_ip.request()}
    """
    return cm_response

@user_log(log=False, pack=False)
@cm_request
def assign(cm_response, **data):
    """
    Assigns public IP to caller's VM with id \c vm_id

    @clmview_user
    @cm_request_transparent{user.public_ip.assign()}
    """
    return cm_response

@user_log(log=False, pack=False)
@cm_request
def unassign(cm_response, **data):
    """
    Unassigns public IP from VM with given id. Unassigned public IP may be assigned
    to any of his VMs.

    @clmview_user
    @cm_request_transparent{user.public_ip.unassign()}
    """
    return cm_response

@user_log(log=True, pack=False)
@cm_request
def release(cm_response, **data):
    """
    Removes IP from callers public IP's pool and makes it available
    for other users to be further requested. Caller doesn't dispose this IP
    any more. He'll have to send another request if he needs more IPs.

    @clmview_user
    @cm_request_transparent{user.public_ip.release()}
    """
    return cm_response


text:
"""
A file full of bit twidling helpers
"""

import struct

MAX_WORD = 32  # usually no more than 8, 16 is for SIMD register support

# Masks to use for unsigned anding to size
u_maxes = [(2 ** (8*i)) - 1 for i in range(MAX_WORD+1)]
u_maxes[0] = 0  # powers of 0 are 1, but we need 0
bu_maxes = [(2 ** (i)) - 1 for i in range(8*MAX_WORD+1)]

# Masks of just the sign bit for different sizes
sign_bits = [(2 ** (8*i)) >> 1 for i in range(MAX_WORD+1)]
sign_bits[0] = 0  # powers of 0 are 1, but we need 0
bsign_bits = [(2 ** i) >> 1 for i in range(8*MAX_WORD+1)]

# Max *signed* masks (all but top bit )
s_maxes = [u_maxes[i] ^ sign_bits[i] for i in range(len(u_maxes))]
s_maxes[0] = 0

# bit width masks
b_masks = [(2**i)-1 for i in range(MAX_WORD*8)]
b_masks[0] = 0

def unsigned(value, size):
    """
    Make a value unsigned based on it's size.
    """
    return value & u_maxes[size]

def signed(value, size):
    """
    Make a value signed based on it's size.
    """
    x = unsigned(value, size)
    if x & sign_bits[size]:
        x = (x - u_maxes[size]) - 1
    return x

def bsigned(value, size):
    """
    Make a value signed based on it's size.
    """
    if value & bsign_bits[size]:
        value = (value - bu_maxes[size]) - 1
    return value

def is_signed(value, size):
    x = unsigned(value, size)
    return bool(x & sign_bits[size])

def sign_extend(value, cursize, newsize):
    """
    Take a value and extend it's size filling
    in the space with the value of the high
    order bit.
    """
    x = unsigned(value, cursize)
    if cursize != newsize:
        # Test for signed w/o the call
        if x & sign_bits[cursize]:
            delta = newsize - cursize
            highbits = u_maxes[delta]
            x |= highbits << (8*cursize)
    return x

def bsign_extend(value, cursize, newsize):
    x = value
    if cursize != newsize:
        if x & bsign_bits[cursize]:
            delta = newsize - cursize
            highbits = bu_maxes[delta]
            x |= highbits << (cursize)
    return x

def is_parity(val):
    s = 0
    while val:
        s ^= val & 1
        val = val >> 1
    return (not s)

parity_table = []
for i in range(256):
    parity_table.append(is_parity(i))

def is_parity_byte(bval):
    """
    An "optimized" parity checker that looks up the index.
    """
    return parity_table[bval & 0xff]

def lsb(value):
    return value & 0x1

def msb(value, size):
    if value & sign_bits[size]:
        return 1
    return 0

def is_signed_half_carry(value, size, src):
    '''
    BCD carry/borrow in the second most important nibble:
        32bit   - bit 27
        16bit   - bit 11
        8bit    - bit 3
    '''
    bitsize = (size << 3) - 5
    mask = 1<<bitsize

    p1 = value & mask
    p2 = src & mask

    return ((p1 ^ p2) != 0)

def is_signed_carry(value, size, src):
    smax = s_maxes[size]
    if value > smax > src:
        return True
    if value < -smax < -src:
        return True
    return False

def is_signed_overflow(value, size):
    smax = s_maxes[size]
    if value > smax:
        return True
    if value < -smax:
        return True
    return False

def is_unsigned_carry(value, size):
    umax = u_maxes[size]
    if value > umax:
        return True
    elif value < 0:
        return True
    return False

def is_aux_carry(src, dst):
    return (dst & 0xf) + (src & 0xf) > 15

def is_aux_carry_sub(src, dst):
    return src & 0xf > dst & 0xf

# set of format lists which make size, endianness, and signedness fast and easy
le_fmt_chars = (None, "B", "<H", None, "<I", None, None, None, "<Q")
be_fmt_chars = (None, "B", ">H", None, ">I", None, None, None, ">Q")
fmt_chars = (le_fmt_chars, be_fmt_chars)

le_fmt_schars = (None,"b","<h",None,"<i",None,None,None,"<q")
be_fmt_schars = (None,"b",">h",None,">i",None,None,None,">q")
fmt_schars = (le_fmt_schars, be_fmt_schars)

master_fmts = (fmt_chars, fmt_schars)

fmt_sizes =  (None,1,2,4,4,8,8,8,8)

le_fmt_float = (None, None, None, None, '<f', None, None, None, '<d')
be_fmt_float = (None, None, None, None, '>f', None, None, None, '>d')

fmt_floats = (le_fmt_float, be_fmt_float)

def getFormat(size, big_endian=False, signed=False):
    '''
    Returns the proper struct format for numbers up to 8 bytes in length
    Endianness and Signedness aware.

    Only useful for *full individual* numbers... ie. 1, 2, 4, 8.  Numbers
    of 24-bits (3), 40-bit (5), 48-bits (6) or 56-bits (7) are not accounted
    for here and will return None.
    '''
    return master_fmts[signed][big_endian][size]

def getFloatFormat(size, big_endian=False):
    '''
    Returns the proper struct format for numbers up to 8 bytes in length
    Endianness and Signedness aware.

    Only useful for *full individual* numbers... ie. 1, 2, 4, 8.  Numbers
    of 24-bits (3), 40-bit (5), 48-bits (6) or 56-bits (7) are not accounted
    for here and will return None.
    '''
    return fmt_floats[big_endian][size]

def parsebytes(bytes, offset, size, sign=False, bigend=False):
    """
    Mostly for pulling immediates out of strings...
    """
    if size > 8:
        return slowparsebytes(bytes, offset, size, sign=sign, bigend=bigend)
    if bigend:
        f = be_fmt_chars[size]
    else:
        f = le_fmt_chars[size]
    if f is None:
        return slowparsebytes(bytes, offset, size, sign=sign, bigend=bigend)
    d = bytes[offset:offset+size]
    x = struct.unpack(f, d)[0]
    if sign:
        x = signed(x, size)
    return x

def slowparsebytes(bytes, offset, size, sign=False, bigend=False):
    if bigend:
        begin = offset
        inc = 1
    else:
        begin = offset + (size-1)
        inc = -1

    ret = 0
    ioff = 0
    for x in range(size):
        ret = ret << 8
        ret |= bytes[begin+ioff]
        ioff += inc
    if sign:
        ret = signed(ret, size)
    return ret

def buildbytes(value, size, bigend=False):
    value = unsigned(value, size)
    if bigend:
        f = be_fmt_chars[size]
    else:
        f = le_fmt_chars[size]
    if f is None:
        raise Exception("envi.bits.buildbytes needs slowbuildbytes")
    return struct.pack(f, value)

def byteswap(value, size):
    ret = 0
    for i in range(size):
        ret = ret << 8
        ret |= (value >> (8*i)) & 0xff
    return ret

hex_fmt = {
    0:'0x%.1x',
    1:"0x%.2x",
    2:"0x%.4x",
    4:"0x%.8x",
    8:"0x%.16x",
}

def intwidth(val):
    if val < 0:
        val = abs(val)
    ret = 0
    while val:
        ret += 1
        val = val >> 8
    return ret

def hex(value, size=None):
    if size is None:
        size = intwidth(value)

    fmt = hex_fmt.get(size)
    if fmt is not None:
        return fmt % value

    x = []
    while value:
        x.append('%.2x' % (value & 0xff))
        value = value >> 8
    x.reverse()
    return '0x%.s' % ''.join(x)

    return hex_fmt.get(size) % value

def binrepr(intval, bitwidth=None):
    '''
    Return a string of one's and zero's for the given value.
    '''
    ret = []
    while intval:
        ret.append(str(intval & 0x1))
        intval >>= 1
    ret.reverse()
    binstr = ''.join(ret)
    if bitwidth is not None:
        binstr = binstr.rjust(bitwidth, '0')
    return binstr

def binary(binstr):
    '''
    Decode a binary string of 1/0's into a python number
    '''
    return int(binstr, 2)

def binbytes(binstr):
    '''
    Decode a binary string of 1/0's into a python binary
    string.
    '''
    if len(binstr) % 8 != 0:
        raise Exception('Byte padded binary strings only for now!')
    bytez = ''
    while binstr:
        bytez += chr(binary(binstr[:8]))
        binstr = binstr[8:]
    return bytez

def parsebits(bytes, offset, bitoff, bitsize):
    '''
    Parse bitsize bits from the bit offset bitoff beginning
    at offset bytes.

    Example:
    '''
    val = 0
    cnt = 0
    while cnt < bitsize:

        addbit = bitoff + cnt
        addoff = offset + (addbit >> 3)

        modoff = addbit % 8

        o = bytes[addoff]
        val = (val << 1) + ((o >> (7 - modoff)) & 1)

        cnt += 1

    return val

def masktest(s):
    '''
    Specify a bit mask with the following syntax:
    '110100xxx00xx' to return a tester callback which will
    determine if an integer value meets the mask.

    example:
        opcode = 0x4388e234
        if masktest('1011xxxx0000')(opcode):
            print('MATCHED!')

    NOTE: For performance reasons, it is recommeneded that
    masktest be used to initialize a static list of tests
    that are re-used rather than reconstructed.
    '''
    maskin = binary(s.replace('0', '1').replace('x', '0'))
    matchval = binary(s.replace('x', '0'))

    def domask(testval):
        return testval & maskin == matchval
    return domask


text:
"""
Created on Mon Oct 19 12:58:07 2015

@author: mariapanteli
"""
import librosa
import scipy.signal
import numpy

class MFCCs:
    def __init__(self):
        self.y = None
        self.sr = None
        self.melspec = None
        self.melsr = None
        self.win1 = None
        self.hop1 = None
        self.mfccs = None

    def load_audiofile(self, filename='test.wav', sr=None, segment=True):
        self.y, self.sr = librosa.load(filename, sr=sr)
        if segment:
            tracklength = self.y.shape[0]/float(self.sr)
            startSample = 0
            endSample = None
            if tracklength > 90:
                startPointSec = (tracklength/2.)-20
                startSample = round(startPointSec*self.sr)
                endSample = startSample+45*self.sr
            self.y = self.y[startSample:endSample]

    def mel_spectrogram(self, y=None, sr=None):
        if self.y is None:
            self.y = y
        if self.sr is None:
            self.sr = sr
        win1 = int(round(0.04*self.sr))
        hop1 = int(round(win1/8.))
        nfft1 = int(2**numpy.ceil(numpy.log2(win1)))
        nmels = 40
        D = numpy.abs(librosa.stft(self.y, n_fft=nfft1, hop_length=hop1, win_length=win1, window=scipy.signal.hamming))**2
        #melspec = librosa.feature.melspectrogram(S=D, sr=self.sr, n_mels=nmels)
        melspec = librosa.feature.melspectrogram(S=D, sr=self.sr, n_mels=nmels, fmax=8000)
        melsr = self.sr/float(hop1)
        self.melspec = melspec
        self.melsr = melsr

    def calc_mfccs(self, y=None, sr=None):
        if self.y is None:
            self.y = y
        if self.sr is None:
            self.sr = sr
        # require log-amplitude
        self.mfccs = librosa.feature.mfcc(S=librosa.amplitude_to_db(self.melspec), n_mfcc=21)
        # remove DCT component
        self.mfccs = self.mfccs[1:,:]

    def get_mfccs(self, filename='test.wav', secondframedecomp=False):
        self.load_audiofile(filename=filename)
        self.mel_spectrogram()
        self.calc_mfccs()

        if secondframedecomp:
            win2 = int(round(8*self.melsr))
            hop2 = int(round(0.5*self.melsr))
            nbins, norigframes = self.melspec.shape
            nframes = int(1+numpy.floor((norigframes-win2)/float(hop2)))
            avemfccs = numpy.empty((nbins, nframes))
            for i in range(nframes):  # loop over all 8-sec frames
                avemfccs[:,i] = numpy.mean(self.mfccs[:, (i*hop2):(i*hop2+win2)], axis=1, keepdims=True)
            self.mfccs = avemfccs
        return self.mfccs

    def get_mfccs_from_melspec(self, melspec=[], melsr=[]):
        self.melspec = melspec
        self.melsr = melsr
        self.calc_mfccs()
        return self.mfccs

if __name__ == '__main__':
    mfs = MFCCs()
    mfs.get_mfccs()


text:
<?php
require_once vc_path_dir( 'SHORTCODES_DIR', 'vc-tta-accordion.php' );

class WPBakeryShortCode_VC_Tta_Section extends WPBakeryShortCode_VC_Tta_Accordion {
	protected $controls_css_settings = 'tc vc_control-container';
	protected $controls_list = array( 'add', 'edit', 'clone', 'delete' );
	// protected $controls_template_file = 'editors/partials/backend_controls_tab.tpl.php'; // used to remove 'dragabble'
	protected $backened_editor_prepend_controls = false;
	/**
	 * @var WPBakeryShortCode_VC_Tta_Accordion
	 */
	public static $tta_base_shortcode;
	public static $self_count = 0;
	public static $section_info = array();

	public function getFileName() {
		return 'vc_tta_section';
	}

	public function containerContentClass() {
		return 'wpb_column_container vc_container_for_children vc_clearfix';
	}

	public function getElementClasses() {
		$classes = array();
		$classes[] = 'vc_tta-panel';
		$isActive = ! vc_is_page_editable() && $this->getTemplateVariable( 'section-is-active' );

		if ( $isActive ) {
			$classes[] = $this->activeClass;
		}

		/**
		 * @since 4.6.2
		 */
		if ( isset( $this->atts['el_class'] ) ) {
			$classes[] = $this->atts['el_class'];
		}

		return implode( ' ', array_filter( $classes ) );
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string
	 */
	public function getParamContent( $atts, $content ) {
		return wpb_js_remove_wpautop( $content );
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string|null
	 */
	public function getParamTabId( $atts, $content ) {
		if ( isset( $atts['tab_id'] ) && strlen( $atts['tab_id'] ) > 0 ) {
			return $atts['tab_id'];
		}

		return null;
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string|null
	 */
	public function getParamTitle( $atts, $content ) {
		if ( isset( $atts['title'] ) && strlen( $atts['title'] ) > 0 ) {
			return $atts['title'];
		}

		return null;
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string|null
	 */
	public function getParamIcon( $atts, $content ) {
		if ( ! empty( $atts['add_icon'] ) && 'true' === $atts['add_icon'] ) {
			$iconClass = '';
			if ( isset( $atts[ 'i_icon_' . $atts['i_type'] ] ) ) {
				$iconClass = $atts[ 'i_icon_' . $atts['i_type'] ];
			}
			vc_icon_element_fonts_enqueue( $atts['i_type'] );

			return '';
		}

		return null;
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string|null
	 */
	public function getParamIconLeft( $atts, $content ) {
		if ( 'left' === $atts['i_position'] ) {
			return $this->getParamIcon( $atts, $content );
		}

		return null;
	}

	/**
	 * @param $atts
	 * @param $content
	 *
	 * @return string|null
	 */
	public function getParamIconRight( $atts, $content ) {
		if ( 'right' === $atts['i_position'] ) {
			return $this->getParamIcon( $atts, $content );
		}

		return null;
	}

	/**
	 * Section param active
	 */
	public function getParamSectionIsActive( $atts, $content ) {
		if ( is_object( self::$tta_base_shortcode ) ) {
			if ( isset( self::$tta_base_shortcode->atts['active_section'] ) && strlen( self::$tta_base_shortcode->atts['active_section'] ) > 0 ) {
				$active = (int) self::$tta_base_shortcode->atts['active_section'];
				if ( $active === self::$self_count ) {
					return true;
				}
			}
		}

		return null;
	}

	public function getParamControlIconPosition( $atts, $content ) {
		if ( is_object( self::$tta_base_shortcode ) ) {
			if (
				isset( self::$tta_base_shortcode->atts['c_icon'] ) && strlen( self::$tta_base_shortcode->atts['c_icon'] ) > 0 &&
				isset( self::$tta_base_shortcode->atts['c_position'] ) && strlen( self::$tta_base_shortcode->atts['c_position'] ) > 0
			) {
				$c_position = self::$tta_base_shortcode->atts['c_position'];

				return 'vc_tta-controls-icon-position-' . $c_position;
			}
		}

		return null;
	}

	public function getParamControlIcon( $atts, $content ) {
		if ( is_object( self::$tta_base_shortcode ) ) {
			if ( isset( self::$tta_base_shortcode->atts['c_icon'] ) && strlen( self::$tta_base_shortcode->atts['c_icon'] ) > 0 ) {
				$c_icon = self::$tta_base_shortcode->atts['c_icon'];

				return '';
			}
		}

		return null;
	}

	public function getParamHeading( $atts, $content ) {
		$isPageEditable = vc_is_page_editable();

		$h4attributes = array();
		$h4classes = array(
			'vc_tta-panel-title',
		);
		if ( $isPageEditable ) {
			$h4attributes[] = 'data-vc-tta-controls-icon-position=""';
		} else {
			$controlIconPosition = $this->getTemplateVariable( 'control-icon-position' );
			if ( $controlIconPosition ) {
				$h4classes[] = $controlIconPosition;
			}
		}
		$h4attributes[] = 'class="' . implode( ' ', $h4classes ) . '"';

		$output = '
'; // close h4

		if ( $isPageEditable ) {
			$output .= '<a href="javascript:;" data-vc-target=""';
			$output .= ' data-vc-tta-controls-icon-wrapper';
			$output .= ' data-vc-use-cache="false"';
		} else {
			$output .= 'getTemplateVariable( 'tab_id' ) ) . '"';
		}

		$output .= ' data-vc-accordion';

		$output .= ' data-vc-container=".vc_tta-container">';
		$output .= $this->getTemplateVariable( 'icon-left' );
		$output .= ''
		           . esc_html( $this->getTemplateVariable( 'title' ) )
		           . '';
		$output .= $this->getTemplateVariable( 'icon-right' );
		if ( ! $isPageEditable ) {
			$output .= $this->getTemplateVariable( 'control-icon' );
		}

		$output .= '';
		$output .= '
'; // close h4 fix #2229

		return $output;
	}
}