text:
<?php
/**
 * These functions are needed to load WordPress.
 *
 * @internal This file must be parsable by PHP4.
 *
 * @package WordPress
 */

/**
 * Return the HTTP protocol sent by the server.
 *
 * @since 4.4.0
 *
 * @return string The HTTP protocol. Default: HTTP/1.0.
 */
function wp_get_server_protocol() {
	$protocol = $_SERVER['SERVER_PROTOCOL'];
	if ( ! in_array( $protocol, array( 'HTTP/1.1', 'HTTP/2', 'HTTP/2.0' ) ) ) {
		$protocol = 'HTTP/1.0';
	}
	return $protocol;
}

/**
 * Turn register globals off.
 *
 * @since 2.1.0
 * @access private
 */
function wp_unregister_GLOBALS() {
	if ( !ini_get( 'register_globals' ) )
		return;

	if ( isset( $_REQUEST['GLOBALS'] ) )
		die( 'GLOBALS overwrite attempt detected' );

	// Variables that shouldn't be unset
	$no_unset = array( 'GLOBALS', '_GET', '_POST', '_COOKIE', '_REQUEST', '_SERVER', '_ENV', '_FILES', 'table_prefix' );

	$input = array_merge( $_GET, $_POST, $_COOKIE, $_SERVER, $_ENV, $_FILES, isset( $_SESSION ) && is_array( $_SESSION ) ? $_SESSION : array() );
	foreach ( $input as $k => $v )
		if ( !in_array( $k, $no_unset ) && isset( $GLOBALS[$k] ) ) {
			unset( $GLOBALS[$k] );
		}
}

/**
 * Fix `$_SERVER` variables for various setups.
 *
 * @since 3.0.0
 * @access private
 *
 * @global string $PHP_SELF The filename of the currently executing script,
 *                          relative to the document root.
 */
function wp_fix_server_vars() {
	global $PHP_SELF;

	$default_server_values = array(
		'SERVER_SOFTWARE' => '',
		'REQUEST_URI' => '',
	);

	$_SERVER = array_merge( $default_server_values, $_SERVER );

	// Fix for IIS when running with PHP ISAPI
	if ( empty( $_SERVER['REQUEST_URI'] ) || ( PHP_SAPI != 'cgi-fcgi' && preg_match( '/^Microsoft-IIS\//', $_SERVER['SERVER_SOFTWARE'] ) ) ) {

		// IIS Mod-Rewrite
		if ( isset( $_SERVER['HTTP_X_ORIGINAL_URL'] ) ) {
			$_SERVER['REQUEST_URI'] = $_SERVER['HTTP_X_ORIGINAL_URL'];
		}
		// IIS Isapi_Rewrite
		elseif ( isset( $_SERVER['HTTP_X_REWRITE_URL'] ) ) {
			$_SERVER['REQUEST_URI'] = $_SERVER['HTTP_X_REWRITE_URL'];
		} else {
			// Use ORIG_PATH_INFO if there is no PATH_INFO
			if ( !isset( $_SERVER['PATH_INFO'] ) && isset( $_SERVER['ORIG_PATH_INFO'] ) )
				$_SERVER['PATH_INFO'] = $_SERVER['ORIG_PATH_INFO'];

			// Some IIS + PHP configurations puts the script-name in the path-info (No need to append it twice)
			if ( isset( $_SERVER['PATH_INFO'] ) ) {
				if ( $_SERVER['PATH_INFO'] == $_SERVER['SCRIPT_NAME'] )
					$_SERVER['REQUEST_URI'] = $_SERVER['PATH_INFO'];
				else
					$_SERVER['REQUEST_URI'] = $_SERVER['SCRIPT_NAME'] . $_SERVER['PATH_INFO'];
			}

			// Append the query string if it exists and isn't null
			if ( ! empty( $_SERVER['QUERY_STRING'] ) ) {
				$_SERVER['REQUEST_URI'] .= '?' . $_SERVER['QUERY_STRING'];
			}
		}
	}

	// Fix for PHP as CGI hosts that set SCRIPT_FILENAME to something ending in php.cgi for all requests
	if ( isset( $_SERVER['SCRIPT_FILENAME'] ) && ( strpos( $_SERVER['SCRIPT_FILENAME'], 'php.cgi' ) == strlen( $_SERVER['SCRIPT_FILENAME'] ) - 7 ) )
		$_SERVER['SCRIPT_FILENAME'] = $_SERVER['PATH_TRANSLATED'];

	// Fix for Dreamhost and other PHP as CGI hosts
	if ( strpos( $_SERVER['SCRIPT_NAME'], 'php.cgi' ) !== false )
		unset( $_SERVER['PATH_INFO'] );

	// Fix empty PHP_SELF
	$PHP_SELF = $_SERVER['PHP_SELF'];
	if ( empty( $PHP_SELF ) )
		$_SERVER['PHP_SELF'] = $PHP_SELF = preg_replace( '/(\?.*)?$/', '', $_SERVER["REQUEST_URI"] );
}

/**
 * Check for the required PHP version, and the MySQL extension or
 * a database drop-in.
 *
 * Dies if requirements are not met.
 *
 * @since 3.0.0
 * @access private
 *
 * @global string $required_php_version The required PHP version string.
 * @global string $wp_version           The WordPress version string.
 */
function wp_check_php_mysql_versions() {
	global $required_php_version, $wp_version;
	$php_version = phpversion();

	if ( version_compare( $required_php_version, $php_version, '>' ) ) {
		wp_load_translations_early();

		$protocol = wp_get_server_protocol();
		header( sprintf( '%s 500 Internal Server Error', $protocol ), true, 500 );
		header( 'Content-Type: text/html; charset=utf-8' );
		die( sprintf( __( 'Your server is running PHP version %1$s but WordPress %2$s requires at least %3$s.' ), $php_version, $wp_version, $required_php_version ) );
	}

	if ( ! extension_loaded( 'mysql' ) && ! extension_loaded( 'mysqli' ) && ! extension_loaded( 'mysqlnd' ) && ! file_exists( WP_CONTENT_DIR . '/db.php' ) ) {
		wp_load_translations_early();

		$protocol = wp_get_server_protocol();
		header( sprintf( '%s 500 Internal Server Error', $protocol ), true, 500 );
		header( 'Content-Type: text/html; charset=utf-8' );
		die( __( 'Your PHP installation appears to be missing the MySQL extension which is required by WordPress.' ) );
	}
}

/**
 * Don't load all of WordPress when handling a favicon.ico request.
 *
 * Instead, send the headers for a zero-length favicon and bail.
 *
 * @since 3.0.0
 */
function wp_favicon_request() {
	if ( '/favicon.ico' == $_SERVER['REQUEST_URI'] ) {
		header('Content-Type: image/vnd.microsoft.icon');
		exit;
	}
}

/**
 * Die with a maintenance message when conditions are met.
 *
 * Checks for a file in the WordPress root directory named ".maintenance".
 * This file will contain the variable $upgrading, set to the time the file
 * was created. If the file was created less than 10 minutes ago, WordPress
 * enters maintenance mode and displays a message.
 *
 * The default message can be replaced by using a drop-in (maintenance.php in
 * the wp-content directory).
 *
 * @since 3.0.0
 * @access private
 *
 * @global int $upgrading the unix timestamp marking when upgrading WordPress began.
 */
function wp_maintenance() {
	if ( ! file_exists( ABSPATH . '.maintenance' ) || wp_installing() )
		return;

	global $upgrading;

	include( ABSPATH . '.maintenance' );
	// If the $upgrading timestamp is older than 10 minutes, don't die.
	if ( ( time() - $upgrading ) >= 600 )
		return;

	/**
	 * Filters whether to enable maintenance mode.
	 *
	 * This filter runs before it can be used by plugins. It is designed for
	 * non-web runtimes. If this filter returns true, maintenance mode will be
	 * active and the request will end. If false, the request will be allowed to
	 * continue processing even if maintenance mode should be active.
	 *
	 * @since 4.6.0
	 *
	 * @param bool $enable_checks Whether to enable maintenance mode. Default true.
	 * @param int  $upgrading     The timestamp set in the .maintenance file.
	 */
	if ( ! apply_filters( 'enable_maintenance_mode', true, $upgrading ) ) {
		return;
	}

	if ( file_exists( WP_CONTENT_DIR . '/maintenance.php' ) ) {
		require_once( WP_CONTENT_DIR . '/maintenance.php' );
		die();
	}

	wp_load_translations_early();

	$protocol = wp_get_server_protocol();
	header( "$protocol 503 Service Unavailable", true, 503 );
	header( 'Content-Type: text/html; charset=utf-8' );
	header( 'Retry-After: 600' );
?>
	<!DOCTYPE html>
	<html xmlns="http://www.w3.org/1999/xhtml"<?php if ( is_rtl() ) echo ' dir="rtl"'; ?>>

	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<title><?php _e( 'Maintenance' ); ?></title>

<?php _e( 'Briefly unavailable for scheduled maintenance. Check back in a minute.' ); ?>

<?php
	die();
}

/**
 * Start the WordPress micro-timer.
 *
 * @since 0.71
 * @access private
 *
 * @global float $timestart Unix timestamp set at the beginning of the page load.
 * @see timer_stop()
 *
 * @return bool Always returns true.
 */
function timer_start() {
	global $timestart;
	$timestart = microtime( true );
	return true;
}

/**
 * Retrieve or display the time from the page start to when function is called.
 *
 * @since 0.71
 *
 * @global float   $timestart Seconds from when timer_start() is called.
 * @global float   $timeend   Seconds from when function is called.
 *
 * @param int|bool $display   Whether to echo or return the results. Accepts 0|false for return,
 *                            1|true for echo. Default 0|false.
 * @param int      $precision The number of digits from the right of the decimal to display.
 *                            Default 3.
 * @return string The "second.microsecond" finished time calculation. The number is formatted
 *                for human consumption, both localized and rounded.
 */
function timer_stop( $display = 0, $precision = 3 ) {
	global $timestart, $timeend;
	$timeend = microtime( true );
	$timetotal = $timeend - $timestart;
	$r = ( function_exists( 'number_format_i18n' ) ) ? number_format_i18n( $timetotal, $precision ) : number_format( $timetotal, $precision );
	if ( $display )
		echo $r;
	return $r;
}

/**
 * Set PHP error reporting based on WordPress debug settings.
 *
 * Uses three constants: `WP_DEBUG`, `WP_DEBUG_DISPLAY`, and `WP_DEBUG_LOG`.
 * All three can be defined in wp-config.php. By default, `WP_DEBUG` and
 * `WP_DEBUG_LOG` are set to false, and `WP_DEBUG_DISPLAY` is set to true.
 *
 * When `WP_DEBUG` is true, all PHP notices are reported. WordPress will also
 * display internal notices: when a deprecated WordPress function, function
 * argument, or file is used. Deprecated code may be removed from a later
 * version.
 *
 * It is strongly recommended that plugin and theme developers use `WP_DEBUG`
 * in their development environments.
 *
 * `WP_DEBUG_DISPLAY` and `WP_DEBUG_LOG` perform no function unless `WP_DEBUG`
 * is true.
 *
 * When `WP_DEBUG_DISPLAY` is true, WordPress will force errors to be displayed.
 * `WP_DEBUG_DISPLAY` defaults to true. Defining it as null prevents WordPress
 * from changing the global configuration setting. Defining `WP_DEBUG_DISPLAY`
 * as false will force errors to be hidden.
 *
 * When `WP_DEBUG_LOG` is true, errors will be logged to debug.log in the content
 * directory.
 *
 * Errors are never displayed for XML-RPC, REST, and Ajax requests.
 *
 * @since 3.0.0
 * @access private
 */
function wp_debug_mode() {
	/**
	 * Filters whether to allow the debug mode check to occur.
	 *
	 * This filter runs before it can be used by plugins. It is designed for
	 * non-web run-times. Returning false causes the `WP_DEBUG` and related
	 * constants to not be checked and the default php values for errors
	 * will be used unless you take care to update them yourself.
	 *
	 * @since 4.6.0
	 *
	 * @param bool $enable_debug_mode Whether to enable debug mode checks to occur. Default true.
	 */
	if ( ! apply_filters( 'enable_wp_debug_mode_checks', true ) ){
		return;
	}

	if ( WP_DEBUG ) {
		error_reporting( E_ALL );

		if ( WP_DEBUG_DISPLAY )
			ini_set( 'display_errors', 1 );
		elseif ( null !== WP_DEBUG_DISPLAY )
			ini_set( 'display_errors', 0 );

		if ( WP_DEBUG_LOG ) {
			ini_set( 'log_errors', 1 );
			ini_set( 'error_log', WP_CONTENT_DIR . '/debug.log' );
		}
	} else {
		error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );
	}

	if ( defined( 'XMLRPC_REQUEST' ) || defined( 'REST_REQUEST' ) || ( defined( 'DOING_AJAX' ) && DOING_AJAX ) ) {
		@ini_set( 'display_errors', 0 );
	}
}

/**
 * Set the location of the language directory.
 *
 * To set directory manually, define the `WP_LANG_DIR` constant
 * in wp-config.php.
 *
 * If the language directory exists within `WP_CONTENT_DIR`, it
 * is used. Otherwise the language directory is assumed to live
 * in `WPINC`.
 *
 * @since 3.0.0
 * @access private
 */
function wp_set_lang_dir() {
	if ( !defined( 'WP_LANG_DIR' ) ) {
		if ( file_exists( WP_CONTENT_DIR . '/languages' ) && @is_dir( WP_CONTENT_DIR . '/languages' ) || !@is_dir(ABSPATH . WPINC . '/languages') ) {
			/**
			 * Server path of the language directory.
			 *
			 * No leading slash, no trailing slash, full path, not relative to ABSPATH
			 *
			 * @since 2.1.0
			 */
			define( 'WP_LANG_DIR', WP_CONTENT_DIR . '/languages' );
			if ( !defined( 'LANGDIR' ) ) {
				// Old static relative path maintained for limited backward compatibility - won't work in some cases.
				define( 'LANGDIR', 'wp-content/languages' );
			}
		} else {
			/**
			 * Server path of the language directory.
			 *
			 * No leading slash, no trailing slash, full path, not relative to `ABSPATH`.
			 *
			 * @since 2.1.0
			 */
			define( 'WP_LANG_DIR', ABSPATH . WPINC . '/languages' );
			if ( !defined( 'LANGDIR' ) ) {
				// Old relative path maintained for backward compatibility.
				define( 'LANGDIR', WPINC . '/languages' );
			}
		}
	}
}

/**
 * Load the database class file and instantiate the `$wpdb` global.
 *
 * @since 2.5.0
 *
 * @global wpdb $wpdb The WordPress database class.
 */
function require_wp_db() {
	global $wpdb;

	require_once( ABSPATH . WPINC . '/wp-db.php' );
	if ( file_exists( WP_CONTENT_DIR . '/db.php' ) )
		require_once( WP_CONTENT_DIR . '/db.php' );

	if ( isset( $wpdb ) )
		return;

	$wpdb = new wpdb( DB_USER, DB_PASSWORD, DB_NAME, DB_HOST );
}

/**
 * Set the database table prefix and the format specifiers for database
 * table columns.
 *
 * Columns not listed here default to `%s`.
 *
 * @since 3.0.0
 * @access private
 *
 * @global wpdb   $wpdb         The WordPress database class.
 * @global string $table_prefix The database table prefix.
 */
function wp_set_wpdb_vars() {
	global $wpdb, $table_prefix;
	if ( !empty( $wpdb->error ) )
		dead_db();

	$wpdb->field_types = array( 'post_author' => '%d', 'post_parent' => '%d', 'menu_order' => '%d', 'term_id' => '%d', 'term_group' => '%d', 'term_taxonomy_id' => '%d',
		'parent' => '%d', 'count' => '%d','object_id' => '%d', 'term_order' => '%d', 'ID' => '%d', 'comment_ID' => '%d', 'comment_post_ID' => '%d', 'comment_parent' => '%d',
		'user_id' => '%d', 'link_id' => '%d', 'link_owner' => '%d', 'link_rating' => '%d', 'option_id' => '%d', 'blog_id' => '%d', 'meta_id' => '%d', 'post_id' => '%d',
		'user_status' => '%d', 'umeta_id' => '%d', 'comment_karma' => '%d', 'comment_count' => '%d',
		// multisite:
		'active' => '%d', 'cat_id' => '%d', 'deleted' => '%d', 'lang_id' => '%d', 'mature' => '%d', 'public' => '%d', 'site_id' => '%d', 'spam' => '%d',
	);

	$prefix = $wpdb->set_prefix( $table_prefix );

	if ( is_wp_error( $prefix ) ) {
		wp_load_translations_early();
		wp_die(
			/* translators: 1: $table_prefix 2: wp-config.php */
			sprintf( __( 'ERROR: %1$s in %2$s can only contain numbers, letters, and underscores.' ),
				'$table_prefix',
				'wp-config.php'
			)
		);
	}
}

/**
 * Toggle `$_wp_using_ext_object_cache` on and off without directly
 * touching global.
 *
 * @since 3.7.0
 *
 * @global bool $_wp_using_ext_object_cache
 *
 * @param bool $using Whether external object cache is being used.
 * @return bool The current 'using' setting.
 */
function wp_using_ext_object_cache( $using = null ) {
	global $_wp_using_ext_object_cache;
	$current_using = $_wp_using_ext_object_cache;
	if ( null !== $using )
		$_wp_using_ext_object_cache = $using;
	return $current_using;
}

/**
 * Start the WordPress object cache.
 *
 * If an object-cache.php file exists in the wp-content directory,
 * it uses that drop-in as an external object cache.
 *
 * @since 3.0.0
 * @access private
 *
 * @global int $blog_id Blog ID.
 */
function wp_start_object_cache() {
	global $blog_id;

	$first_init = false;
 	if ( ! function_exists( 'wp_cache_init' ) ) {
		if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
			require_once ( WP_CONTENT_DIR . '/object-cache.php' );
			if ( function_exists( 'wp_cache_init' ) )
				wp_using_ext_object_cache( true );
		}

		$first_init = true;
	} elseif ( ! wp_using_ext_object_cache() && file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
		/*
		 * Sometimes advanced-cache.php can load object-cache.php before
		 * it is loaded here. This breaks the function_exists check above
		 * and can result in `$_wp_using_ext_object_cache` being set
		 * incorrectly. Double check if an external cache exists.
		 */
		wp_using_ext_object_cache( true );
	}

	if ( ! wp_using_ext_object_cache() )
		require_once ( ABSPATH . WPINC . '/cache.php' );

	/*
	 * If cache supports reset, reset instead of init if already
	 * initialized. Reset signals to the cache that global IDs
	 * have changed and it may need to update keys and cleanup caches.
	 */
	if ( ! $first_init && function_exists( 'wp_cache_switch_to_blog' ) )
		wp_cache_switch_to_blog( $blog_id );
	elseif ( function_exists( 'wp_cache_init' ) )
		wp_cache_init();

	if ( function_exists( 'wp_cache_add_global_groups' ) ) {
		wp_cache_add_global_groups( array( 'users', 'userlogins', 'usermeta', 'user_meta', 'useremail', 'userslugs', 'site-transient', 'site-options', 'site-lookup', 'blog-lookup', 'blog-details', 'site-details', 'rss', 'global-posts', 'blog-id-cache', 'networks', 'sites' ) );
		wp_cache_add_non_persistent_groups( array( 'counts', 'plugins' ) );
	}
}

/**
 * Redirect to the installer if WordPress is not installed.
 *
 * Dies with an error message when Multisite is enabled.
 *
 * @since 3.0.0
 * @access private
 */
function wp_not_installed() {
	if ( is_multisite() ) {
		if ( ! is_blog_installed() && ! wp_installing() ) {
			nocache_headers();

			wp_die( __( 'The site you have requested is not installed properly. Please contact the system administrator.' ) );
		}
	} elseif ( ! is_blog_installed() && ! wp_installing() ) {
		nocache_headers();

		require( ABSPATH . WPINC . '/kses.php' );
		require( ABSPATH . WPINC . '/pluggable.php' );
		require( ABSPATH . WPINC . '/formatting.php' );

		$link = wp_guess_url() . '/wp-admin/install.php';

		wp_redirect( $link );
		die();
	}
}

/**
 * Retrieve an array of must-use plugin files.
 *
 * The default directory is wp-content/mu-plugins. To change the default
 * directory manually, define `WPMU_PLUGIN_DIR` and `WPMU_PLUGIN_URL`
 * in wp-config.php.
 *
 * @since 3.0.0
 * @access private
 *
 * @return array Files to include.
 */
function wp_get_mu_plugins() {
	$mu_plugins = array();
	if ( !is_dir( WPMU_PLUGIN_DIR ) )
		return $mu_plugins;
	if ( ! $dh = opendir( WPMU_PLUGIN_DIR ) )
		return $mu_plugins;
	while ( ( $plugin = readdir( $dh ) ) !== false ) {
		if ( substr( $plugin, -4 ) == '.php' )
			$mu_plugins[] = WPMU_PLUGIN_DIR . '/' . $plugin;
	}
	closedir( $dh );
	sort( $mu_plugins );

	return $mu_plugins;
}

/**
 * Retrieve an array of active and valid plugin files.
 *
 * While upgrading or installing WordPress, no plugins are returned.
 *
 * The default directory is wp-content/plugins. To change the default
 * directory manually, define `WP_PLUGIN_DIR` and `WP_PLUGIN_URL`
 * in wp-config.php.
 *
 * @since 3.0.0
 * @access private
 *
 * @return array Files.
 */
function wp_get_active_and_valid_plugins() {
	$plugins = array();
	$active_plugins = (array) get_option( 'active_plugins', array() );

	// Check for hacks file if the option is enabled
	if ( get_option( 'hack_file' ) && file_exists( ABSPATH . 'my-hacks.php' ) ) {
		_deprecated_file( 'my-hacks.php', '1.5.0' );
		array_unshift( $plugins, ABSPATH . 'my-hacks.php' );
	}

	if ( empty( $active_plugins ) || wp_installing() )
		return $plugins;

	$network_plugins = is_multisite() ? wp_get_active_network_plugins() : false;

	foreach ( $active_plugins as $plugin ) {
		if ( ! validate_file( $plugin ) // $plugin must validate as file
			&& '.php' == substr( $plugin, -4 ) // $plugin must end with '.php'
			&& file_exists( WP_PLUGIN_DIR . '/' . $plugin ) // $plugin must exist
			// not already included as a network plugin
			&& ( ! $network_plugins || ! in_array( WP_PLUGIN_DIR . '/' . $plugin, $network_plugins ) )
			)
		$plugins[] = WP_PLUGIN_DIR . '/' . $plugin;
	}
	return $plugins;
}

/**
 * Set internal encoding.
 *
 * In most cases the default internal encoding is latin1, which is
 * of no use, since we want to use the `mb_` functions for `utf-8` strings.
 *
 * @since 3.0.0
 * @access private
 */
function wp_set_internal_encoding() {
	if ( function_exists( 'mb_internal_encoding' ) ) {
		$charset = get_option( 'blog_charset' );
		if ( ! $charset || ! @mb_internal_encoding( $charset ) )
			mb_internal_encoding( 'UTF-8' );
	}
}

/**
 * Add magic quotes to `$_GET`, `$_POST`, `$_COOKIE`, and `$_SERVER`.
 *
 * Also forces `$_REQUEST` to be `$_GET + $_POST`. If `$_SERVER`,
 * `$_COOKIE`, or `$_ENV` are needed, use those superglobals directly.
 *
 * @since 3.0.0
 * @access private
 */
function wp_magic_quotes() {
	// If already slashed, strip.
	if ( get_magic_quotes_gpc() ) {
		$_GET    = stripslashes_deep( $_GET    );
		$_POST   = stripslashes_deep( $_POST   );
		$_COOKIE = stripslashes_deep( $_COOKIE );
	}

	// Escape with wpdb.
	$_GET    = add_magic_quotes( $_GET    );
	$_POST   = add_magic_quotes( $_POST   );
	$_COOKIE = add_magic_quotes( $_COOKIE );
	$_SERVER = add_magic_quotes( $_SERVER );

	// Force REQUEST to be GET + POST.
	$_REQUEST = array_merge( $_GET, $_POST );
}

/**
 * Runs just before PHP shuts down execution.
 *
 * @since 1.2.0
 * @access private
 */
function shutdown_action_hook() {
	/**
	 * Fires just before PHP shuts down execution.
	 *
	 * @since 1.2.0
	 */
	do_action( 'shutdown' );

	wp_cache_close();
}

/**
 * Copy an object.
 *
 * @since 2.7.0
 * @deprecated 3.2.0
 *
 * @param object $object The object to clone.
 * @return object The cloned object.
 */
function wp_clone( $object ) {
	// Use parens for clone to accommodate PHP 4. See #17880
	return clone( $object );
}

/**
 * Whether the current request is for an administrative interface page.
 *
 * Does not check if the user is an administrator; current_user_can()
 * for checking roles and capabilities.
 *
 * @since 1.5.1
 *
 * @global WP_Screen $current_screen
 *
 * @return bool True if inside WordPress administration interface, false otherwise.
 */
function is_admin() {
	if ( isset( $GLOBALS['current_screen'] ) )
		return $GLOBALS['current_screen']->in_admin();
	elseif ( defined( 'WP_ADMIN' ) )
		return WP_ADMIN;

	return false;
}

/**
 * Whether the current request is for a site's admininstrative interface.
 *
 * e.g. `/wp-admin/`
 *
 * Does not check if the user is an administrator; current_user_can()
 * for checking roles and capabilities.
 *
 * @since 3.1.0
 *
 * @global WP_Screen $current_screen
 *
 * @return bool True if inside WordPress blog administration pages.
 */
function is_blog_admin() {
	if ( isset( $GLOBALS['current_screen'] ) )
		return $GLOBALS['current_screen']->in_admin( 'site' );
	elseif ( defined( 'WP_BLOG_ADMIN' ) )
		return WP_BLOG_ADMIN;

	return false;
}

/**
 * Whether the current request is for the network administrative interface.
 *
 * e.g. `/wp-admin/network/`
 *
 * Does not check if the user is an administrator; current_user_can()
 * for checking roles and capabilities.
 *
 * @since 3.1.0
 *
 * @global WP_Screen $current_screen
 *
 * @return bool True if inside WordPress network administration pages.
 */
function is_network_admin() {
	if ( isset( $GLOBALS['current_screen'] ) )
		return $GLOBALS['current_screen']->in_admin( 'network' );
	elseif ( defined( 'WP_NETWORK_ADMIN' ) )
		return WP_NETWORK_ADMIN;

	return false;
}

/**
 * Whether the current request is for a user admin screen.
 *
 * e.g. `/wp-admin/user/`
 *
 * Does not inform on whether the user is an admin! Use capability
 * checks to tell if the user should be accessing a section or not
 * current_user_can().
 *
 * @since 3.1.0
 *
 * @global WP_Screen $current_screen
 *
 * @return bool True if inside WordPress user administration pages.
 */
function is_user_admin() {
	if ( isset( $GLOBALS['current_screen'] ) )
		return $GLOBALS['current_screen']->in_admin( 'user' );
	elseif ( defined( 'WP_USER_ADMIN' ) )
		return WP_USER_ADMIN;

	return false;
}

/**
 * If Multisite is enabled.
 *
 * @since 3.0.0
 *
 * @return bool True if Multisite is enabled, false otherwise.
 */
function is_multisite() {
	if ( defined( 'MULTISITE' ) )
		return MULTISITE;

	if ( defined( 'SUBDOMAIN_INSTALL' ) || defined( 'VHOST' ) || defined( 'SUNRISE' ) )
		return true;

	return false;
}

/**
 * Retrieve the current site ID.
 *
 * @since 3.1.0
 *
 * @global int $blog_id
 *
 * @return int Site ID.
 */
function get_current_blog_id() {
	global $blog_id;
	return absint($blog_id);
}

/**
 * Retrieves the current network ID.
 *
 * @since 4.6.0
 *
 * @global WP_Network $current_site The current network.
 *
 * @return int The ID of the current network.
 */
function get_current_network_id() {
	if ( ! is_multisite() ) {
		return 1;
	}

	$current_site = get_current_site();

	if ( ! isset( $current_site->id ) ) {
		return get_main_network_id();
	}

	return absint( $current_site->id );
}

/**
 * Attempt an early load of translations.
 *
 * Used for errors encountered during the initial loading process, before
 * the locale has been properly detected and loaded.
 *
 * Designed for unusual load sequences (like setup-config.php) or for when
 * the script will then terminate with an error, otherwise there is a risk
 * that a file can be double-included.
 *
 * @since 3.4.0
 * @access private
 *
 * @global string    $text_direction
 * @global WP_Locale $wp_locale      The WordPress date and time locale object.
 *
 * @staticvar bool $loaded
 */
function wp_load_translations_early() {
	global $text_direction, $wp_locale;

	static $loaded = false;
	if ( $loaded )
		return;
	$loaded = true;

	if ( function_exists( 'did_action' ) && did_action( 'init' ) )
		return;

	// We need $wp_local_package
	require ABSPATH . WPINC . '/version.php';

	// Translation and localization
	require_once ABSPATH . WPINC . '/pomo/mo.php';
	require_once ABSPATH . WPINC . '/l10n.php';
	require_once ABSPATH . WPINC . '/locale.php';

	// General libraries
	require_once ABSPATH . WPINC . '/plugin.php';

	$locales = $locations = array();

	while ( true ) {
		if ( defined( 'WPLANG' ) ) {
			if ( '' == WPLANG )
				break;
			$locales[] = WPLANG;
		}

		if ( isset( $wp_local_package ) )
			$locales[] = $wp_local_package;

		if ( ! $locales )
			break;

		if ( defined( 'WP_LANG_DIR' ) && @is_dir( WP_LANG_DIR ) )
			$locations[] = WP_LANG_DIR;

		if ( defined( 'WP_CONTENT_DIR' ) && @is_dir( WP_CONTENT_DIR . '/languages' ) )
			$locations[] = WP_CONTENT_DIR . '/languages';

		if ( @is_dir( ABSPATH . 'wp-content/languages' ) )
			$locations[] = ABSPATH . 'wp-content/languages';

		if ( @is_dir( ABSPATH . WPINC . '/languages' ) )
			$locations[] = ABSPATH . WPINC . '/languages';

		if ( ! $locations )
			break;

		$locations = array_unique( $locations );

		foreach ( $locales as $locale ) {
			foreach ( $locations as $location ) {
				if ( file_exists( $location . '/' . $locale . '.mo' ) ) {
					load_textdomain( 'default', $location . '/' . $locale . '.mo' );
					if ( defined( 'WP_SETUP_CONFIG' ) && file_exists( $location . '/admin-' . $locale . '.mo' ) )
						load_textdomain( 'default', $location . '/admin-' . $locale . '.mo' );
					break 2;
				}
			}
		}

		break;
	}

	$wp_locale = new WP_Locale();
}

/**
 * Check or set whether WordPress is in "installation" mode.
 *
 * If the `WP_INSTALLING` constant is defined during the bootstrap, `wp_installing()` will default to `true`.
 *
 * @since 4.4.0
 *
 * @staticvar bool $installing
 *
 * @param bool $is_installing Optional. True to set WP into Installing mode, false to turn Installing mode off.
 *                            Omit this parameter if you only want to fetch the current status.
 * @return bool True if WP is installing, otherwise false. When a `$is_installing` is passed, the function will
 *              report whether WP was in installing mode prior to the change to `$is_installing`.
 */
function wp_installing( $is_installing = null ) {
	static $installing = null;

	// Support for the `WP_INSTALLING` constant, defined before WP is loaded.
	if ( is_null( $installing ) ) {
		$installing = defined( 'WP_INSTALLING' ) && WP_INSTALLING;
	}

	if ( ! is_null( $is_installing ) ) {
		$old_installing = $installing;
		$installing = $is_installing;
		return (bool) $old_installing;
	}

	return (bool) $installing;
}

/**
 * Determines if SSL is used.
 *
 * @since 2.6.0
 * @since 4.6.0 Moved from functions.php to load.php.
 *
 * @return bool True if SSL, otherwise false.
 */
function is_ssl() {
	if ( isset( $_SERVER['HTTPS'] ) ) {
		if ( 'on' == strtolower( $_SERVER['HTTPS'] ) ) {
			return true;
		}

		if ( '1' == $_SERVER['HTTPS'] ) {
			return true;
		}
	} elseif ( isset($_SERVER['SERVER_PORT'] ) && ( '443' == $_SERVER['SERVER_PORT'] ) ) {
		return true;
	}
	return false;
}

/**
 * Converts a shorthand byte value to an integer byte value.
 *
 * @since 2.3.0
 * @since 4.6.0 Moved from media.php to load.php.
 *
 * @link http://php.net/manual/en/function.ini-get.php
 * @link http://php.net/manual/en/faq.using.php#faq.using.shorthandbytes
 *
 * @param string $value A (PHP ini) byte value, either shorthand or ordinary.
 * @return int An integer byte value.
 */
function wp_convert_hr_to_bytes( $value ) {
	$value = strtolower( trim( $value ) );
	$bytes = (int) $value;

	if ( false !== strpos( $value, 'g' ) ) {
		$bytes *= GB_IN_BYTES;
	} elseif ( false !== strpos( $value, 'm' ) ) {
		$bytes *= MB_IN_BYTES;
	} elseif ( false !== strpos( $value, 'k' ) ) {
		$bytes *= KB_IN_BYTES;
	}

	// Deal with large (float) values which run into the maximum integer size.
	return min( $bytes, PHP_INT_MAX );
}

/**
 * Determines whether a PHP ini value is changeable at runtime.
 *
 * @since 4.6.0
 *
 * @link http://php.net/manual/en/function.ini-get-all.php
 *
 * @param string $setting The name of the ini setting to check.
 * @return bool True if the value is changeable at runtime. False otherwise.
 */
function wp_is_ini_value_changeable( $setting ) {
	static $ini_all;

	if ( ! isset( $ini_all ) ) {
		$ini_all = ini_get_all();
	}

	// Bit operator to workaround https://bugs.php.net/bug.php?id=44936 which changes access level to 63 in PHP 5.2.6 - 5.2.17.
	if ( isset( $ini_all[ $setting ]['access'] ) && ( INI_ALL === ( $ini_all[ $setting ]['access'] & 7 ) || INI_USER === ( $ini_all[ $setting ]['access'] & 7 ) ) ) {
		return true;
	}

	return false;
}


text:
package com.facebook.buck.android;

import com.facebook.buck.event.BuckEventBus;
import com.facebook.buck.event.ConsoleEvent;
import com.google.common.base.Supplier;
import java.util.Optional;
import javax.annotation.Nullable;

// TODO(mbolin): Only one such Supplier should be created per Cell per Buck execution.
// Currently, only one Supplier is created per Buck execution because Main creates the Supplier
// and passes it from above all the way through, but it is not parameterized by Cell.
//
// TODO(mbolin): Every build rule that uses AndroidPlatformTarget must include the result
// of its getCacheName() method in its RuleKey.

public class AndroidPlatformTargetSupplier implements Supplier<AndroidPlatformTarget> {
  private final AndroidDirectoryResolver androidDirectoryResolver;
  private final AndroidBuckConfig androidBuckConfig;
  private final BuckEventBus eventBus;

  @Nullable private AndroidPlatformTarget androidPlatformTarget;
  @Nullable private RuntimeException exception;

  public AndroidPlatformTargetSupplier(
      final AndroidDirectoryResolver androidDirectoryResolver,
      final AndroidBuckConfig androidBuckConfig,
      final BuckEventBus eventBus) {
    this.androidDirectoryResolver = androidDirectoryResolver;
    this.androidBuckConfig = androidBuckConfig;
    this.eventBus = eventBus;
  }

  @Override
  public AndroidPlatformTarget get() {
    if (androidPlatformTarget != null) {
      return androidPlatformTarget;
    } else if (exception != null) {
      throw exception;
    }

    String androidPlatformTargetId;
    Optional<String> target = androidBuckConfig.getAndroidTarget();
    if (target.isPresent()) {
      androidPlatformTargetId = target.get();
    } else {
      androidPlatformTargetId = AndroidPlatformTarget.DEFAULT_ANDROID_PLATFORM_TARGET;
      eventBus.post(
          ConsoleEvent.fine(
              "No Android platform target specified. Using default: %s", androidPlatformTargetId));
    }

    try {
      androidPlatformTarget =
          AndroidPlatformTarget.getTargetForId(
              androidPlatformTargetId,
              androidDirectoryResolver,
              androidBuckConfig.getAaptOverride(),
              androidBuckConfig.getAapt2Override());
      return androidPlatformTarget;
    } catch (RuntimeException e) {
      exception = e;
      throw e;
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
package org.pepstock.charba.client.gwt.widgets;

import org.pepstock.charba.client.IsDatasetCreator;
import org.pepstock.charba.client.StackedBarChart;
import org.pepstock.charba.client.configuration.StackedBarOptions;
import org.pepstock.charba.client.data.StackedBarDataset;

/**
 * STACKED BAR chart GWT WIDGET implementation.

 * Stacked bar charts can be configured like bar charts and changes the settings on the X and Y axes to enable stacking.

 * Stacked bar charts can be used to show how one data series is made up of a number of smaller pieces.
 *
 * @author Andrea "Stock" Stocchero
 *
 */
public class StackedBarChartWidget extends AbstractChartWidget<StackedBarChart> implements IsDatasetCreator<StackedBarDataset> {

	/**
	 * Builds the object.
	 */
	public StackedBarChartWidget() {
		this(new StackedBarChart());
	}

	/**
	 * Builds the chart.

	 * This is must be extended for controller which are based on this chart.
	 *
	 * @param extendedChart new chart
	 */
	protected StackedBarChartWidget(StackedBarChart extendedChart) {
		super(extendedChart);
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.pepstock.charba.client.IsChart#getOptions()
	 */
	@Override
	public StackedBarOptions getOptions() {
		return getChart().getOptions();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see org.pepstock.charba.client.gwt.widgets.AbstractChartWidget#newDataset(boolean)
	 */
	@Override
	public StackedBarDataset newDataset(boolean hidden) {
		return getChart().newDataset(hidden);
	}
}


text:
#pragma once

#include <wangle/deprecated/rx/types.h> // must come first
#include <wangle/deprecated/rx/Subject.h>
#include <wangle/deprecated/rx/Subscription.h>

#include <folly/RWSpinLock.h>
#include <folly/SmallLocks.h>
#include <folly/ThreadLocal.h>
#include <folly/small_vector.h>
#include <folly/Executor.h>
#include <folly/Memory.h>
#include <map>
#include <memory>

namespace wangle {

template <class T, size_t InlineObservers>
class Observable {
 public:
  Observable() : nextSubscriptionId_{1} {}

  // TODO perhaps we want to provide this #5283229
  Observable(Observable&& other) = delete;

  virtual ~Observable() {
    if (unsubscriber_) {
      unsubscriber_->disable();
    }
  }

  // The next three methods subscribe the given Observer to this Observable.
  //
  // If these are called within an Observer callback, the new observer will not
  // get the current update but will get subsequent updates.
  //
  // subscribe() returns a Subscription object. The observer will continue to
  // get updates until the Subscription is destroyed.
  //
  // observe(ObserverPtr<T>) creates an indefinite subscription
  //
  // observe(Observer<T>*) also creates an indefinite subscription, but the
  // caller is responsible for ensuring that the given Observer outlives this
  // Observable. This might be useful in high performance environments where
  // allocations must be kept to a minimum. Template parameter InlineObservers
  // specifies how many observers can been subscribed inline without any
  // allocations (it's just the size of a folly::small_vector).
  virtual Subscription<T> subscribe(ObserverPtr<T> observer) {
    return subscribeImpl(observer, false);
  }

  virtual void observe(ObserverPtr<T> observer) {
    subscribeImpl(observer, true);
  }

  virtual void observe(Observer<T>* observer) {
    if (inCallback_ && *inCallback_) {
      if (!newObservers_) {
        newObservers_.reset(new ObserverList());
      }
      newObservers_->push_back(observer);
    } else {
      folly::RWSpinLock::WriteHolder{&observersLock_};
      observers_.push_back(observer);
    }
  }

  // TODO unobserve(ObserverPtr<T>), unobserve(Observer<T>*)

  /// Returns a new Observable that will call back on the given Scheduler.
  /// The returned Observable must outlive the parent Observable.

  // This and subscribeOn should maybe just be a first-class feature of an
  // Observable, rather than making new ones whose lifetimes are tied to their
  // parents. In that case it'd return a reference to this object for
  // chaining.
  ObservablePtr<T> observeOn(SchedulerPtr scheduler) {
    // you're right Hannes, if we have Observable::create we don't need this
    // helper class.
    struct ViaSubject : public Observable<T>
    {
      ViaSubject(SchedulerPtr sched,
                 Observable* obs)
        : scheduler_(sched), observable_(obs)
      {}

      Subscription<T> subscribe(ObserverPtr<T> o) override {
        return observable_->subscribe(
          Observer<T>::create(
            [=](T val) { scheduler_->add([o, val] { o->onNext(val); }); },
            [=](Error e) { scheduler_->add([o, e] { o->onError(e); }); },
            [=]() { scheduler_->add([o] { o->onCompleted(); }); }));
      }

     protected:
      SchedulerPtr scheduler_;
      Observable* observable_;
    };

    return std::make_shared<ViaSubject>(scheduler, this);
  }

  /// Returns a new Observable that will subscribe to this parent Observable
  /// via the given Scheduler. This can be subtle and confusing at first, see
  /// http://www.introtorx.com/Content/v1.0.10621.0/15_SchedulingAndThreading.html#SubscribeOnObserveOn
  std::unique_ptr<Observable> subscribeOn(SchedulerPtr scheduler) {
    struct Subject_ : public Subject<T> {
     public:
      Subject_(SchedulerPtr s, Observable* o) : scheduler_(s), observable_(o) {
      }

      Subscription<T> subscribe(ObserverPtr<T> o) {
        scheduler_->add([=] {
          observable_->subscribe(o);
        });
        return Subscription<T>(nullptr, 0); // TODO
      }

     protected:
      SchedulerPtr scheduler_;
      Observable* observable_;
    };

    return folly::make_unique<Subject_>(scheduler, this);
  }

 protected:
  // Safely execute an operation on each observer. F must take a single
  // Observer<T>* as its argument.
  template <class F>
  void forEachObserver(F f) {
    if (UNLIKELY(!inCallback_)) {
      inCallback_.reset(new bool{false});
    }
    CHECK(!(*inCallback_));
    *inCallback_ = true;

    {
      folly::RWSpinLock::ReadHolder rh(observersLock_);
      for (auto o : observers_) {
        f(o);
      }

      for (auto& kv : subscribers_) {
        f(kv.second.get());
      }
    }

    if (UNLIKELY((newObservers_ && !newObservers_->empty()) ||
                 (newSubscribers_ && !newSubscribers_->empty()) ||
                 (oldSubscribers_ && !oldSubscribers_->empty()))) {
      {
        folly::RWSpinLock::WriteHolder wh(observersLock_);
        if (newObservers_) {
          for (auto observer : *(newObservers_)) {
            observers_.push_back(observer);
          }
          newObservers_->clear();
        }
        if (newSubscribers_) {
          for (auto& kv : *(newSubscribers_)) {
            subscribers_.insert(std::move(kv));
          }
          newSubscribers_->clear();
        }
        if (oldSubscribers_) {
          for (auto id : *(oldSubscribers_)) {
            subscribers_.erase(id);
          }
          oldSubscribers_->clear();
        }
      }
    }
    *inCallback_ = false;
  }

 private:
  Subscription<T> subscribeImpl(ObserverPtr<T> observer, bool indefinite) {
    auto subscription = makeSubscription(indefinite);
    typename SubscriberMap::value_type kv{subscription.id_, std::move(observer)};
    if (inCallback_ && *inCallback_) {
      if (!newSubscribers_) {
        newSubscribers_.reset(new SubscriberMap());
      }
      newSubscribers_->insert(std::move(kv));
    } else {
      folly::RWSpinLock::WriteHolder{&observersLock_};
      subscribers_.insert(std::move(kv));
    }
    return subscription;
  }

  class Unsubscriber {
   public:
    explicit Unsubscriber(Observable* observable) : observable_(observable) {
      CHECK(observable_);
    }

    void unsubscribe(uint64_t id) {
      CHECK(id > 0);
      folly::RWSpinLock::ReadHolder guard(lock_);
      if (observable_) {
        observable_->unsubscribe(id);
      }
    }

    void disable() {
      folly::RWSpinLock::WriteHolder guard(lock_);
      observable_ = nullptr;
    }

   private:
    folly::RWSpinLock lock_;
    Observable* observable_;
  };

  std::shared_ptr<Unsubscriber> unsubscriber_{nullptr};
  folly::MicroSpinLock unsubscriberLock_{0};

  friend class Subscription<T>;

  void unsubscribe(uint64_t id) {
    if (inCallback_ && *inCallback_) {
      if (!oldSubscribers_) {
        oldSubscribers_.reset(new std::vector<uint64_t>());
      }
      if (newSubscribers_) {
        auto it = newSubscribers_->find(id);
        if (it != newSubscribers_->end()) {
          newSubscribers_->erase(it);
          return;
        }
      }
      oldSubscribers_->push_back(id);
    } else {
      folly::RWSpinLock::WriteHolder{&observersLock_};
      subscribers_.erase(id);
    }
  }

  Subscription<T> makeSubscription(bool indefinite) {
    if (indefinite) {
      return Subscription<T>(nullptr, nextSubscriptionId_++);
    } else {
      if (!unsubscriber_) {
        std::lock_guard<folly::MicroSpinLock> guard(unsubscriberLock_);
        if (!unsubscriber_) {
          unsubscriber_ = std::make_shared<Unsubscriber>(this);
        }
      }
      return Subscription<T>(unsubscriber_, nextSubscriptionId_++);
    }
  }

  std::atomic<uint64_t> nextSubscriptionId_;
  folly::RWSpinLock observersLock_;
  folly::ThreadLocalPtr<bool> inCallback_;

  typedef folly::small_vector<Observer<T>*, InlineObservers> ObserverList;
  ObserverList observers_;
  folly::ThreadLocalPtr<ObserverList> newObservers_;

  typedef std::map<uint64_t, ObserverPtr<T>> SubscriberMap;
  SubscriberMap subscribers_;
  folly::ThreadLocalPtr<SubscriberMap> newSubscribers_;
  folly::ThreadLocalPtr<std::vector<uint64_t>> oldSubscribers_;
};

} // namespace wangle


text:
Commands

Load

Submit

Reset

Keyspaces

{{keyspace}}

    <input type="text" class="form-control" placeholder="Keyspace"
      data-ng-model="newKeyspace">

      <button type="button" class="btn dropdown-toggle" data-toggle="dropdown">

      </button>

Sharded

Unsharded

    {{keyspaceEditor.err}}


text:
package config

type chainLoader struct {
	loaders []Loader
}

// NewChainLoader returns a Loader which will resolve configuration and credentials according to the provided array
// of Loaders.  The loaders are consulted sequentially, first to last.
func NewChainLoader(chain []Loader) *chainLoader {
	return &chainLoader{loaders: chain}
}

// Config will build an AwsConfig object using values looked up via the array of Loaders given to the constructor.
// If an error occurs, the next loader in the chain is consulted until the end of the array.  As such, this method will
// never return an error, but is required to satisfy the Loader interface.
//
// Values retrieved via the various loaders are merged using the AwsConfig.MergeIn() method.
func (l *chainLoader) Config(profile string, sources ...interface{}) (*AwsConfig, error) {
	c := new(AwsConfig)

	for _, ldr := range l.loaders {
		cf, err := ldr.Config(profile, sources...)
		if err != nil {
			logger.Debugf("error loading configuration: %v", err)
		}

		if cf != nil {
			c.MergeIn(cf)
		}
	}

	return c, nil
}

// Credentials will build an AwsCredentials object using values looked up via the array of Loaders given to the constructor.
// If an error occurs, the next loader in the chain is consulted until the end of the array.  As such, this method will
// never return an error, but is required to satisfy the Loader interface.
//
// Values retrieved via the various loaders are merged using the AwsCredentials.MergeIn() method.
func (l *chainLoader) Credentials(profile string, sources ...interface{}) (*AwsCredentials, error) {
	c := new(AwsCredentials)

	for _, ldr := range l.loaders {
		cr, err := ldr.Credentials(profile, sources...)
		if err != nil {
			logger.Debugf("error loading credentials: %v", err)
			continue
		}
		c.MergeIn(cr)
	}

	return c, nil
}


text:
GpgKee
======

GpgKee is a KeePass plugin that provides GPG authentication.

WARNING
-------

The GpgKee plugin is EXTREMELY basic. There is no guarantee that it will work
for you. There is no error handling. There are no tests of any sort. Do not use
this plugin unless you are willing to lose everything in your KeePass database.

About
-----

GpgKee can be used as a secondary component to your KeePass master key. It uses
the GPG application on your computer to decrypt an encrypted secret key. If it
is able to decrypt the key, the key is passed along to KeePass to decrypt your
password database.

GpgKee is currently very minimal. There are no GUI components to help you
generate your encrypted secret key and there is no error handling. These
components should be added eventually, but the plugin works in its current
state.

Usage
-----

GpgKee currently has two requirements:

1. You must have [Gpg4win](http://www.gpg4win.org/) installed to the default
  location. GpgKee is hard coded to use the `gpg2` executable located at
  `C:\Program Files (x86)\GNU\GnuPG\pub\gpg2.exe`.
2. Your pinentry must open in a new window so that when GpgKee executes the
  `gpg2` application, the pinentry application can prompt you for your password.

### Generate GpgKee File

Once you have Gpg4win installed and configured, you need to generate a secret
key. You can use anything you want as the secret key.

Once you have a secret key, encrypt it with GPG:

```cmd
gpg2 --output secret-key.gpg --encrypt --recipient *your public key* secret.key
```

Once you have your encrypted secret key, move it to the same folder as your
KeePass kbdx file and rename it the same name as your KeePass database with a
".gpgkee" extension.

For example, if your KeePass database is called "Personal.kbdx", name your
gpg encrypted secret key "Personal.gpgkee".

### Change Master Key

Now that your secret key is set up, you can change your master key to use the
GpgKee secret key.

1. Open your KeePass database.
2. Click File >> Change Master Key...
3. Check the "Key file / provider" checkbox.
4. Select the "GPG Authentication" provider.
5. Click OK.
6. Type in your GPG key pin if you are prompted.
7. Save your database.

If all went according to plan, when you open your database again, you will be
prompted for your GPG key pin and your password database will open.


text:
package synergyviewcore;

import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.ILog;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;

/**
 * The Class ApplicationWorkbenchWindowAdvisor.
 */
public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {

    /** The logger. */
    private final ILog logger;

    /**
     * Instantiates a new application workbench window advisor.
     *
     * @param configurer
     *            the configurer
     */
    public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
	super(configurer);
	logger = Activator.getDefault().getLog();

    }

    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#createActionBarAdvisor (org.eclipse.ui.application.IActionBarConfigurer)
     */
    public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) {
	return new ApplicationActionBarAdvisor(configurer);
    }

    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#postWindowClose()
     */
    @Override
    public void postWindowClose() {
	super.postWindowClose();
	try {
	    ResourcesPlugin.getWorkspace().save(true, null);
	} catch (CoreException ex) {
	    IStatus status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, ex.getMessage(), ex);
	    logger.log(status);
	}
    }

    /*
     * (non-Javadoc)
     *
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#preWindowOpen()
     */
    @Override
    public void preWindowOpen() {
	IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
	configurer.setInitialSize(new Point(1280, 800));
	configurer.setShowCoolBar(false);
	configurer.setShowStatusLine(true);
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _03.Endurance_Rally
{
    class Program
    {
        static void Main(string[] args)
        {
            var drivers = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
            var stops = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(double.Parse).ToList();
            var checkpointsIndexes = Console.ReadLine().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToList();

            foreach (var driver in drivers)
            {
                var remainingFuel = (double)driver[0];

                for (int i = 0; i < stops.Count; i++)
                {
                    if (checkpointsIndexes.Contains(i))
                    {
                        remainingFuel += stops[i];
                    }
                    else
                    {
                        remainingFuel -= stops[i];
                    }

                    if (remainingFuel <= 0)
                    {
                        Console.WriteLine($"{driver} - reached {i}");
                        break;
                    }
                }
                if (remainingFuel > 0)
                {
                    Console.WriteLine($"{driver} - fuel left {remainingFuel:F2}");
                }
            }
        }

    }
}


text:
/** global: titles, year, monthdata, yeardata, request, colors, yearDataset, yearStats */

/**
 * Returns the config object for chart.js, used in profile stats
 *
 * @param {object} bar_data
 * @param {array} tooltips
 * @returns {{data, options: {indexAxis: string, plugins: {legend: {display: boolean}, tooltip: {callbacks: {label: (function(*): *)}}, title: {display: boolean}}, elements: {bar: {borderWidth: number}}, responsive: boolean, scales: {yAxis: {ticks: {font: {size: number}}, grid: {display: boolean}, afterFit: options.scales.yAxis.afterFit}, xAxis: {ticks: {display: boolean, stepSize: number}}}, categoryPercentage: string}, type: string}}
 */
function barConfig(bar_data, tooltips)
{
	return {
		type: "bar",
		data: bar_data,
		options: {
			indexAxis: "y",
			categoryPercentage: ".9",
			elements: {
				bar: {
					borderWidth: 0,
				}
			},
			responsive: true,
			scales: {
				y: {
					grid: {display: false},
					// Sets the yAxis to an initial 200px wide
					afterFit: function(scaleInstance) {
						scaleInstance.width = 200;
					},
					ticks: {
						font: {
							size: 15,
						}
					},
				},
				x: {
					ticks: {
						display: true,
					},
				}
			},
			plugins: {
				title: {
					display: false
				},
				legend: {
					display: false
				},
				tooltip: {
					callbacks: {
						label: function(context) {
							return tooltips[context.dataIndex];
						}
					}
				}
			}
		},
	};
}

/**
 * Click events are tied to each chart button, the data attribute is read and
 * the appropriate dataset is then fed to chart.js.
 *
 * Request and Year are set as `global` values in the showLineChart() function in stats.template
 */
function setYearClickEvents()
{
	document.querySelectorAll(".stats_button").forEach(item => {
		item.addEventListener("click", event => {
			year = event.target.getAttribute("data-year") || year;
			request = event.target.getAttribute("data-title") || request;

			let	newDataset = {
				label: titles[request],
				data: year === "all" ? Object.values(yeardata[request]) : Object.values(monthdata[request][year]),
				backgroundColor: [
					"rgba(" + colors[request] + ", 0.1)",
				],
				borderColor: [
					"rgba(" + colors[request] + ", 1)",
				],
				borderWidth: 1,
				pointStyle: "circle",
				pointRadius: 4,
				lineTension: 0.2,
				fill: "origin"
			};

			// Out with the old and in with the new
			yearDataset.labels = year === "all" ? Object.values(yeardata.axis_labels) : Object.values(monthdata.axis_labels[year]);
			yearDataset.datasets.pop();
			yearDataset.datasets.push(newDataset);
			yearStats.update();
		});
	});
}


text:
package org.lirazs.robolayout.core.resource.state;

import org.lirazs.robolayout.core.collection.NamedNodeMapIterable;
import org.robovm.apple.foundation.NSData;
import org.robovm.apple.foundation.NSURL;
import org.robovm.apple.uikit.UIControlState;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Created on 7/30/2015.
 */
public class ResourceStateList {

    protected List<ResourceStateItem> internalItems;

    public static UIControlState getControlState(String attributeName) {
        long controlState = UIControlState.Normal.value();

        if(attributeName.equals("state_disabled")) {
            controlState |= UIControlState.Disabled.value();
        } else if(attributeName.equals("state_highlighted")) {
            controlState |= UIControlState.Highlighted.value();
        } else if(attributeName.equals("state_selected")) {
            controlState |= UIControlState.Selected.value();
        }
        return new UIControlState(controlState);
    }

    public static UIControlState getControlState(Element element) {
        long controlState = UIControlState.Normal.value();

        NamedNodeMap attributes = element.getAttributes();
        for (Node node : NamedNodeMapIterable.of(attributes)) {
            String attributeName = node.getNodeName();
            String attributeValue = node.getNodeValue();

            int prefixIndex = attributeName.indexOf(':');
            if(prefixIndex != -1) {
                attributeName = attributeName.substring(prefixIndex + 1);
            }

            boolean value = Boolean.valueOf(attributeValue);
            if(value) {
                controlState |= getControlState(attributeName).value();
            }
        }

        return new UIControlState(controlState);
    }

    public static ResourceStateList inflateDocument(Document document) {
        return inflateDocument(document, new ResourceStateList());
    }
    public static ResourceStateList inflateDocument(Document document, ResourceStateList resourceStateList) {

        Element root = document.getDocumentElement();
        if(root.getTagName().equals("selector")) {
            List<ResourceStateItem> items = new ArrayList<>();

            Node child = root.getFirstChild();
            if(child != null) {
                do {
                    if (child.getNodeType() == Node.ELEMENT_NODE) {
                        Element elem = (Element) child;

                        UIControlState controlState = getControlState(elem);
                        ResourceStateItem item = resourceStateList.createItem(controlState);

                        items.add(item);
                    }
                } while ((child = child.getNextSibling()) != null);
            }

            resourceStateList.internalItems = items;
        }

        return resourceStateList;
    }

    public static ResourceStateList create(NSData data) {
        return create(data, new ResourceStateList());
    }
    public static ResourceStateList create(NSData data, ResourceStateList resourceStateList) {
        if(data == null)
            return null;

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        byte[] bytes = data.getBytes();
        if(bytes != null) {
            ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);

            try {
                DocumentBuilder db = factory.newDocumentBuilder();
                InputSource inputSource = new InputSource(inputStream);
                Document document = db.parse(inputSource);

                resourceStateList = inflateDocument(document, resourceStateList);
            } catch (ParserConfigurationException | SAXException | IOException e) {
                e.printStackTrace();
            }
        }
        return resourceStateList;
    }

    public static ResourceStateList create(NSURL url) {
        return create(url, new ResourceStateList());
    }
    public static ResourceStateList create(NSURL url, ResourceStateList resourceStateList) {
        return create(NSData.read(url), resourceStateList);
    }

    public ResourceStateList() {
        internalItems = new ArrayList<>();
    }

    public ResourceStateItem createItem(UIControlState controlState) {
        return new ResourceStateItem(controlState);
    }

    public List<ResourceStateItem> getItems() {
        return internalItems;
    }

    public ResourceStateItem getItem(UIControlState controlState) {
        ResourceStateItem result = null;

        for (ResourceStateItem internalItem : internalItems) {
            long controlStateValue = internalItem.getControlState().value() & controlState.value();
            if(controlStateValue == internalItem.getControlState().value()) {
                result = internalItem;
                break;
            }
        }
        return result;
    }
}


text:
ROOT=../..
TARGET=bayes_net
OBJS=bayes_net.o

EXTRA_FLAGS=-I../common/
EXTRA_LIBS=-lm

RUN_ARGS=--dataset ../../dataset/BNnet/alarm.dsc --root 0 --val 1 --iter 5000
PERF_ARGS=--perf-event PERF_COUNT_HW_CPU_CYCLES PERF_COUNT_HW_INSTRUCTIONS PERF_COUNT_HW_BRANCH_INSTRUCTIONS PERF_COUNT_HW_BRANCH_MISSES PERF_COUNT_HW_CACHE_L1D_READ_ACCESS PERF_COUNT_HW_CACHE_L1D_READ_MISS

include ../common.mk


text:
<?php
/**
 * CPAC_Column_Comment_Reply_To
 *
 * @since 2.0.0
 */
class CPAC_Column_Comment_Reply_To extends CPAC_Column {

	function __construct( $storage_model ) {

		$this->properties['type']	 = 'column-reply_to';
		$this->properties['label']	 = __( 'In Reply To', 'cpac' );

		parent::__construct( $storage_model );
	}

	/**
	 * @see CPAC_Column::get_value()
	 * @since 2.0.0
	 */
	function get_value( $id ) {

		$value = '';

		$comment = get_comment( $id );

		if ( $comment->comment_parent ) {
			$parent = get_comment( $comment->comment_parent );
			$value 	= sprintf( '%2$s', esc_url( get_comment_link( $comment->comment_parent ) ), get_comment_author( $parent->comment_ID ) );
		}

		return $value;
	}
}


text:
package service

import "net"

//ListenerOption listener option
type ListenerOption interface {
	Listen() (net.Listener, error)
}

//TLSOption server tls option interface
type TLSOption interface {
	//ServerIsTLSEnabeld return is server tls enabled
	ServerTLSEnabeld() bool
	//ServerTLSCertPath return server tls cert path
	ServerTLSCertPath() string
	//ServerTLSKeyPath resturn serve tls key path
	ServerTLSKeyPath() string
}


text:
namespace ArcadiaWebForm.Models.Opportunity
{
    public class OpportunityViewModel
    {
        public string Id { get; set; }
        public OpportunityInputModel ExpectedInput { get; set; }
    }
}


text:
/* ______                   ___  __            _
  /_  __/_____ _____ ___   / _ \/ /  __ _____ (_)______
   / / / __/ // (_-<(_-<  / ___/ _ \/ // (_-</ / __(_-<
  /_/ /_/  \_,_/___/___/ /_/  /_//_/\_, /___/_/\__/___/
  Soft-Body Simulation for Unity3D /___/
                                         Heartbroken :( */

using UnityEditor;
using UnityEngine;

[CanEditMultipleObjects]
[CustomEditor(typeof(TxRigidBody))]
public class TxRigidBodyEditor : TxBodyEditor
{
    TxRigidBody[] m_targets;

    SerializedProperty massScale;
    SerializedProperty collision;
    SerializedProperty mesh;
    SerializedProperty shapeCenter;
    SerializedProperty shapeSize;
    SerializedProperty capsuleDirection;
    SerializedProperty margin;
    SerializedProperty matters;
    SerializedProperty interaction;
    SerializedProperty spawnActive;
    SerializedProperty deactivation;
    SerializedProperty deactivationSpeed;
    SerializedProperty deactivationTime;

    protected override void OnEnable()
    {
        base.OnEnable();
        m_targets = new TxRigidBody[targets.Length];
        for (int i = 0; i < targets.Length; ++i) m_targets[i] = (TxRigidBody)targets[i];

        massScale = serializedObject.FindProperty("m_massScale");
        collision = serializedObject.FindProperty("m_collision");
        mesh = serializedObject.FindProperty("m_mesh");
        shapeCenter = serializedObject.FindProperty("m_shapeCenter");
        shapeSize = serializedObject.FindProperty("m_shapeSize");
        capsuleDirection = serializedObject.FindProperty("m_capsuleDirection");
        margin = serializedObject.FindProperty("m_margin");
        matters = serializedObject.FindProperty("m_matters");
        interaction = serializedObject.FindProperty("m_interaction");
        spawnActive = serializedObject.FindProperty("m_spawnActive");
        deactivation = serializedObject.FindProperty("m_deactivation");
        deactivationSpeed = serializedObject.FindProperty("m_deactivationSpeed");
        deactivationTime = serializedObject.FindProperty("m_deactivationTime");
    }

    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        TxEditor.LookLikeControls();

        bool isPlaying = Application.isPlaying;

        GUI.enabled = true && !isPlaying;
        EditorGUILayout.PropertyField(massScale);
        bool sameMass = true;
        for (int i = 1; i < m_targets.Length; ++i)
        {
            if (m_targets[i].mass != m_targets[i - 1].mass)
            {
                sameMass = false;
                break;
            }
        }
        if (sameMass)
        {
            GUI.enabled = false;
            EditorGUILayout.FloatField("Scaled Mass", m_targets[0].mass);
        }
        else
        {
            GUI.enabled = false;
            EditorGUILayout.TextField("Scaled Mass", "-");
        }
        GUI.enabled = true && !isPlaying;
        EditorGUILayout.PropertyField(collision);

        EditorGUI.indentLevel++;
        switch (collision.enumValueIndex)
        {
            case 1:
                EditorGUILayout.PropertyField(mesh);
                break;
            case 2:
                EditorGUILayout.PropertyField(mesh);
                break;
            case 3:
                EditorGUILayout.PropertyField(shapeCenter, new GUIContent("Box Center"));
                EditorGUILayout.PropertyField(shapeSize, new GUIContent("Box Size"));
                break;
            case 4:
                EditorGUILayout.PropertyField(shapeCenter);
                EditorGUILayout.PropertyField(shapeSize.FindPropertyRelative("x"), new GUIContent("Capsule Radius"));
                EditorGUILayout.PropertyField(shapeSize.FindPropertyRelative("y"), new GUIContent("Capsule Height"));
                EditorGUILayout.IntPopup(capsuleDirection, new GUIContent[] { new GUIContent("X-Axis"), new GUIContent("Y-Axis"), new GUIContent("Z-Axis") }, new int[] { 0, 1, 2 });
                break;
            case 5:
                EditorGUILayout.PropertyField(shapeCenter);
                EditorGUILayout.PropertyField(shapeSize.FindPropertyRelative("x"), new GUIContent("Sphere Radius"));
                break;
        }
        EditorGUI.indentLevel--;

        EditorGUI.indentLevel++;
        GUI.enabled = (collision.enumValueIndex > 0) && !isPlaying;
        EditorGUILayout.PropertyField(margin);
        EditorGUILayout.PropertyField(matters, true);
        EditorGUI.indentLevel--;

        SpawnEnabledUI();
        EditorGUI.indentLevel++;
        EditorGUILayout.PropertyField(spawnActive);
        EditorGUI.indentLevel--;
        GUI.enabled = true;
        EditorGUILayout.PropertyField(deactivation);
        EditorGUI.indentLevel++;
        GUI.enabled = deactivation.boolValue;
        EditorGUILayout.PropertyField(deactivationSpeed, new GUIContent("Speed"));
        EditorGUILayout.PropertyField(deactivationTime, new GUIContent("Time"));
        EditorGUI.indentLevel--;

        BodyGroupUI();

        GUI.enabled = true && !isPlaying;
        EditorGUILayout.PropertyField(interaction);

        if (GUI.changed) serializedObject.ApplyModifiedProperties();
    }
}


text:
function Send-GitObject
{
    <#
    .SYNOPSIS
    Sends Git refs and object to a remote repository.

    .DESCRIPTION
    The `Send-GitObject` functions sends objects from a local repository to a remote repository. You specify what refs and objects to send with the `Revision` parameter.

    This command implements the `git push` command.

    .EXAMPLE
    Send-GitObject -Revision 'refs/heads/master'

    Demonstrates how to push the commits on a specific branch to the default remote repository.

    .EXAMPLE
    Send-GitObject -Revision 'refs/heads/master' -RemoteName 'upstream'

    Demonstrates how to push an object (in this case, the master branch) to a specific remote repository, in this case the remote named "upstream".

    .EXAMPLE
    Send-GitObject -Revision 'refs/tags/4.45.6'

    Demonstrates how to push a tag to the default remote repository.

    .EXAMPLE
    Send-GitObject -Tags

    Demonstrates how to push all tags to the default remote repository.
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true,ParameterSetName='ByRefSpec')]
        [string[]]
        # The refs that should be pushed to the remote repository.
        $RefSpec,

        [Parameter(Mandatory=$true,ParameterSetname='Tags')]
        [Switch]
        # Push all tags to the remote repository.
        $Tags,

        [string]
        # The name of the remote repository to send the changes to. The default is `origin`.
        $RemoteName = 'origin',

        [string]
        # The path to the local repository from which to push changes. Defaults to the current directory.
        $RepoRoot = (Get-Location).ProviderPath,

        [pscredential]
        # The credentials to use to connect to the source repository.
        $Credential
    )

    Set-StrictMode -Version 'Latest'
    Use-CallerPreference -Cmdlet $PSCmdlet -SessionState $ExecutionContext.SessionState

    $repo = Find-GitRepository -Path $RepoRoot -Verify

    $pushOptions = New-Object -TypeName 'LibGit2Sharp.PushOptions'
    if( $Credential )
    {
        $gitCredential = New-Object -TypeName 'LibGit2Sharp.SecureUsernamePasswordCredentials'
        $gitCredential.Username = $Credential.UserName
        $gitCredential.Password = $Credential.Password
        $pushOptions.CredentialsProvider = { return $gitCredential }
    }

    $remote = $repo.Network.Remotes | Where-Object { $_.Name -eq $RemoteName }
    if( -not $remote )
    {
        Write-Error -Message ('A remote named "{0}" does not exist.' -f $RemoteName)
        return [Git.Automation.PushResult]::Failed
    }

    if( $Tags )
    {
        $RefSpec = $repo.Tags | ForEach-Object { $_.CanonicalName }
    }

    try
    {
        $repo.Network.Push($remote, $RefSpec, $pushOptions)
        return [Git.Automation.PushResult]::Ok
    }
    catch
    {
        Write-Error -ErrorRecord $_

        switch ( $_.FullyQualifiedErrorId )
        {
            'NonFastForwardException' { return [Git.Automation.PushResult]::Rejected }
            'LibGit2SharpException' { return [Git.Automation.PushResult]::Failed }
            'BareRepositoryException' { return [Git.Automation.PushResult]::Failed }
            default { return [Git.Automation.PushResult]::Failed }
        }
    }
    finally
    {
        $repo.Dispose()
    }

}


text:
using System;

namespace ProjectionSystem.ModelsForTest {
  public class Department : IProjectedItem {
    public int Id { get; set; }
    public Guid UniqueIdentifier { get; set; }
    public string Abbreviation { get; set; }
    public string Name { get; set; }
    public string PhoneNumber { get; set; }
    public PhoneType? PhoneType { get; set; }
    public string ContactName { get; set; }
    public DateTimeOffset ProjectionTime { get; set; }
  }
}


text:
module PushToSns # We need this name to help Rails generators lookup
  module Generators
    class InstallGenerator < Rails::Generators::Base
      desc "Create PushToSNS configuration initializer"

      def self.source_root
        @source_root ||= File.expand_path("../templates", __FILE__)
      end

      def create_config_initializer
        copy_file "config/initializers/push_to_sns.rb"
      end
    end
  end
end


text:
/**
 * Keep track of mocked objects so they can all be unmocked.
 */
var mockedObjects = []

/**
 * Allow `mock-fs` to be loaded lazily and referenced.
 */
var mockFs

/**
 * Decorate an object with mocked properties.
 */
var mock = module.exports = function mock (object, mockObject) {
  var mocked = object._EXAM_MOCKED_ORIGINALS
  if (!mocked) {
    mocked = [{}, {}]
    Object.defineProperty(object, '_EXAM_MOCKED_ORIGINALS', {
      enumerable: false,
      value: mocked
    })
  }
  var pro = mocked[0]
  var own = mocked[1]
  for (var key in mockObject) {
    var index = object.hasOwnProperty(key) ? 1 : 0
    // Only remember one original, whether prototype or own.
    if (typeof pro[key] === 'undefined' && typeof own[key] === 'undefined') {
      mocked[index][key] = object[key]
    }
    object[key] = mockObject[key]
  }
  mockedObjects.push(object)
  return object
}

/**
 * Restore mocked properties to their mocked values.
 */
var unmock = mock.unmock = function unmock (object, keys) {
  // If called with no arguments, unmock all objects that have been mocked.
  if (!arguments.length) {
    mockedObjects.forEach(function (object) {
      unmock(object)
    })
    mockedObjects.length = 0
    unmock.fs()
    unmock.time()
    return
  }
  // If it's a single key, make it an array.
  if (typeof keys === 'string') {
    keys = [keys]
  }
  // If the object has original values for mocked properties, restore them.
  var mocked = object._EXAM_MOCKED_ORIGINALS
  if (mocked) {
    for (var index = 0; index < 2; index++) {
      var originals = keys || mocked[index]
      for (var key in originals) {
        if (index) {
          object[key] = originals[key]
        } else {
          delete object[key]
        }
      }
    }
    // If we weren't deleting specific keys, we no longer need the originals.
    if (!keys) {
      delete object._EXAM_MOCKED_ORIGINALS
    }
  }
  return object
}

/**
 * Decorate a mock function with chainable methods.
 */
function decorateFn (fn) {
  fn.returns = function (value) {
    fn._returns = value
    return fn
  }
  return fn
}

/**
 * Finish the execution of a mock function.
 */
function finishFn (fn) {
  return fn._returns
}

/**
 * Simple mock function: Ignore.
 */
mock.fn = mock.ignore = function () {
  var fn = function () {
    return finishFn(fn)
  }
  return decorateFn(fn)
}

/**
 * Simple mock function: Call counter.
 */
mock.count = function () {
  function fn () {
    fn.value++
    return finishFn(fn)
  }
  fn.value = 0
  return decorateFn(fn)
}

/**
 * Simple mock function: Argument setter.
 */
mock.set = function (index) {
  function fn () {
    fn.value = isNaN(index) ? arguments : arguments[index]
    return finishFn(fn)
  }
  fn.value = []
  return decorateFn(fn)
}

/**
 * Simple mock function: Argument pusher.
 */
mock.args = function (index) {
  function fn () {
    fn.value.push(isNaN(index) ? arguments : arguments[index])
    return finishFn(fn)
  }
  fn.value = []
  return decorateFn(fn)
}

/**
 * Simple mock function: String concatenator.
 */
mock.concat = function (delimiter) {
  delimiter = delimiter || ''
  function fn (data) {
    fn.value += (fn.value ? delimiter : '') + data
    return finishFn(fn)
  }
  fn.value = ''
  return decorateFn(fn)
}

/**
 * Simple mock function: Error thrower.
 */
mock.throw = function (message) {
  function fn () {
    var error = new Error(message)
    error.arguments = arguments
    fn.value.push(error)
    throw error
  }
  fn.value = []
  return decorateFn(fn)
}

// Make a reference to the real file system before mocking.
var fs = require('fs')

/**
 * Load `mock-fs` and create a temporary file system.
 */
mock.fs = function (config, newFs) {
  mockFs = require('mock-fs')
  var fs
  if (newFs) {
    fs = mockFs.fs(config)
  } else {
    mockFs(config)
    fs = require('fs')
  }
  return fs
}

/**
 * Load an array of paths, and return an object for `mock.fs`.
 */
mock.fs.load = function (paths) {
  var load = {}
  paths.forEach(function (path) {
    load[path] = fs.readFileSync(path)
  })
  return load
}

/**
 * Restore the real file system.
 */
unmock.fs = function () {
  if (mockFs) {
    mockFs.restore()
    mockFs = null
  }
}

/**
 * Make the os and cluster modules think there's just one CPU.
 */
mock.cpu = function (options) {
  options = options || {}
  if (typeof options.cpus === 'number') {
    options.cpus = unmock(require('os')).cpus().slice(0, options.cpus)
  }
  if (typeof options.hostname === 'string') {
    options.hostname = mock.fn().returns(options.hostname)
  }
  if (options.fork === false) {
    options.fork = mock.fn()
  }
  var modules = ['os', 'cluster']
  modules.forEach(function (lib) {
    lib = require(lib)
    unmock(lib)
    var mocks = {}
    for (var key in options) {
      if (typeof lib[key] === typeof options[key]) {
        mocks[key] = options[key]
      }
    }
    mock(lib, mocks)
  })
}

/**
 * Unmock the cluster and os modules.
 */
unmock.cpu = function () {
  var modules = ['os', 'cluster']
  modules.forEach(function (lib) {
    unmock(require(lib))
  })
}

// Make references to timers and the real `Date` object before mocking time.
var timers = require('timers')
timers.Date = Date

/**
 * Freeze time to a `Date` constructed with the given `value`.
 */
mock.time = function (value) {
  var date = new timers.Date(value)
  mock.time._CURRENT_TIME = date.getTime()
  mock(timers.Date, {now: MockDate.now})
  global.Date = MockDate
  global.setTimeout = getScheduler(false)
  global.setInterval = getScheduler(true)
  global.clearTimeout = getUnscheduler()
  global.clearInterval = getUnscheduler()
  return mock.time
}

/**
 * Construct a `MockDate` using a `Date` constructor value.
 */
function MockDate (value) {
  // A MockDate constructs an inner date and exposes its methods.
  var innerDate
  // If a value is specified, use it to construct a real date.
  if (arguments.length) {
    innerDate = new timers.Date(value)

  // If time isn't currently mocked, construct a real date for the real time.
  } else if (global.Date === timers.Date) {
    innerDate = new timers.Date()

  // If there's no value and time is mocked, use the current mock time.
  } else {
    innerDate = new timers.Date(mock.time._CURRENT_TIME)
  }
  Object.defineProperty(this, '_INNER_DATE', {
    enumerable: false,
    value: innerDate
  })
}

/**
 * Get the current mock time or real time in milliseconds.
 */
MockDate.now = function () {
  // If time has been unmocked, use the real Date object.
  if (mock.time._CURRENT_TIME === undefined) {
    return realNow()

  // Otherwise, use the mock time value.
  } else {
    return mock.time._CURRENT_TIME
  }
}

// `Date.parse` and `Date.UTC` are not relative to the current time.
MockDate.parse = timers.Date.parse
MockDate.UTC = timers.Date.UTC

// An instance of `MockDate` uses methods from its inner date.
var methods = ['getDate', 'getDay', 'getFullYear', 'getHours', 'getMilliseconds',
  'getMinutes', 'getMonth', 'getSeconds', 'getTime', 'getTimezoneOffset',
  'getUTCDate', 'getUTCDay', 'getUTCFullYear', 'getUTCHours',
  'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth', 'getUTCSeconds',
  'getYear', 'setDate', 'setFullYear', 'setHours', 'setMilliseconds',
  'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate',
  'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes',
  'setUTCMonth', 'setUTCSeconds', 'setYear', 'toDateString', 'toGMTString',
  'toISOString', 'toJSON', 'toLocaleDateString', 'toLocaleString',
  'toLocaleTimeString', 'toString', 'toTimeString', 'toUTCString',
  'valueOf']
methods.forEach(function (name) {
  MockDate.prototype[name] = function () {
    return this._INNER_DATE[name].apply(this._INNER_DATE, arguments)
  }
})

/**
 * Add time to the frozen value.
 */
mock.time.add = function (time) {
  var p = /(\d+)\s*(s|seconds?)?(m|minutes?)?(h|hours?)?(d|days?)?\b/
  time = '' + time
  time.replace(p, function (match, n, s, m, h, d) {
    mock.time._CURRENT_TIME += +n * (s ? 1e3 : m ? 6e4 : h ? 36e5 : d ? 864e5 : 1)
  })
  runSchedules()
}

/**
 * Set `mock.time` to move forward at a faster or slower speed than
 * real time, based on whether `speed` is greater or less than 1.
 */
mock.time.speed = function (speed) {
  // By default, move ahead a thousand times faster than real time.
  mock.time._SPEED = speed || 1e3
  moveTime()
}

/**
 * If mock time is moving forward, schedule a time check.
 */
function moveTime () {
  if (mock.time._SPEED) {
    // Remember what the real time was before updating.
    mock.time._PREVIOUS_TIME = realNow()
    // Set time to be incremented.
    setTimeout(function () {
      var now = realNow()
      var elapsed = now - mock.time._PREVIOUS_TIME
      if (elapsed) {
        var add = elapsed * mock.time._SPEED
        mock.time.add(add)
      }
      moveTime()
    }, 0)
  }
}

/**
 * Return what `Date.now()` would return if it wasn't mocked.
 */
function realNow () {
  // We don't replace the `Date` constructor, so this is safe from stack overflow.
  return (new timers.Date()).getTime()
}

/**
 * `schedules` are the result of mocked `setTimeout` and `setInterval` calls.
 */
var schedules = []
schedules.id = 0

/**
 * The `getScheduler` returns mocks for `setTimeout` and `setInterval`.
 */
function getScheduler (isInterval) {
  return function (fn, time) {
    schedules.push({
      id: ++schedules.id,
      fn: fn,
      time: Date.now() + time,
      interval: isInterval ? time : false
    })
  }
}

/**
 * The `getUnscheduler` returns mocks for `clearTimeout` and `clearInterval`.
 */
function getUnscheduler () {
  // TODO: Create a map of IDs if the schedules array gets large.
  return function (id) {
    for (var i = 0, l = schedules.length; i < l; i++) {
      var schedule = schedules[i]
      if (schedule.id === id) {
        schedules.splice(i, 1)
        break
      }
    }
  }
}

/**
 * When `mock.time.add` is called, run schedules whose time has come.
 */
function runSchedules () {
  // Sort by descending time order.
  schedules.sort(function (a, b) {
    return b.time - a.time
  })
  // Track the soonest interval run time, in case we're already there.
  var minNewTime = Number.MAX_VALUE
  // Iterate, from the end until we reach the current mock time.
  var i = schedules.length - 1
  var schedule = schedules[i]
  while (schedule && (schedule.time <= mock.time._CURRENT_TIME)) {
    schedule.fn()
    // setTimeout schedules can be deleted.
    if (!schedule.interval) {
      schedules.splice(i, 1)

    // setInterval schedules should schedule the next run.
    } else {
      schedule.time += schedule.interval
      minNewTime = Math.min(minNewTime, schedule.time)
    }
    schedule = schedules[--i]
  }
  // If an interval schedule is in the past, catch it up.
  if (minNewTime <= mock.time._CURRENT_TIME) {
    process.nextTick(runSchedules)
  }
}

/**
 * Restore the real `Date` object and time-related functions.
 */
unmock.time = function () {
  delete mock.time._CURRENT_TIME
  delete mock.time._SPEED
  global.Date = timers.Date
  global.setTimeout = timers.setTimeout
  global.setInterval = timers.setInterval
  global.clearTimeout = timers.clearTimeout
  global.clearInterval = timers.clearInterval
  schedules.length = 0
  unmock(timers.Date, 'now')
}

/**
 * Expose `mock-fs` methods as exam/lib/mock methods.a
 */
methods = ['directory', 'file', 'symlink']
methods.forEach(function (method) {
  mock[method] = function () {
    var mockFs = require('mock-fs')
    return mockFs[method].apply(mockFs, arguments)
  }
})