The Middle East & North African banking sector is as diverse as the countries represented within the region with each country at a different stage in the development cycle. As such the needs of these institutions vary from basic core banking systems in the least developed nations to advanced transactional and risk management systems for the leading banks of the GCC.
What is common to all markets is the ever changing demands from consumers which has necessitated that banks deliver new channels for banking services in line with the demands of the farmer with no access to a bank account to the large multinational company that is managing hundreds of thousands transactions a day. However this increased digitization of the banking sector has presented challenges in data storage and security threats.
Banking Technology MENA , that will be held in Dubai from 8 - 10 June, will bring together the regions leading banking IT specialists to network discuss the latest trends in the banking industry and formulate strategies and alliances that will assist them in delivering banking services to their clients in a convenient and secure manner.


text:
Q: Can I access a page's table of contents in a Jekyll layout? I have a layout in my Jekyll site for regular Markdown page, in which I'd like to place an outline of the page's headings. Can I access these headings in Jekyll or have them rendered in some other way, and if so, how?

A: In the depths of the answers to a tangentially related StackOverflow question, I found this answer:

https://github.com/allejo/jekyll-toc provides very easy way to add TOC
  to your jekyll page.

*

*Download the latest toc.html file (caution! should be raw file)

*copy this file to _includes folder.

*add this line before {{content}}: {% include toc.html html=content %}

A: There is also jekyll-toc from toshimaru on GitHub. You can configure which level you want to parse, h1 to h6.

redpajama_set_name: RedPajamaStackExchange


PTFE sheet type material is utilized in a wide range of applications such as valve sheets, gaskets, cushioning materials, insulating materials, and machinery parts. PTFE's features such as chemical stability, electrical stability, and a low friction factor make it applicable in a number of industries.
200-500mm square boards with 5-155mm in thickness are available and used for various uses from lining sheets to component manufacturing by MC.
Abundant discs with outer diameters of φ50 -φ470 are available. The discs are most suitable as a shock-absorbing material in a field needing chemical resistance and certain electrical characteristics.
*Rod materials (cylindrical shape) can be sliced if necessary depending on the amount and size.
*Please click here to see the information about rod materials.
PTFE has the characteristics of chemical stability, electrical stability, and a low friction coefficient. PTFE sleeve rod is a material of cylinder form used for shock-absorbing materials such as valve sheets and v-packing, unlubricated bearings for machine parts, and bellow plumbing of carving processes.
Boasting the largest variation of sizes in Japan, the external diameter φ16.5-φ610 of sleeves are available. Please contact us for your requested size. We will manufacture it with speed and efficiency.
Various sizes of external diameter φ10- φ500 from thin to thick types are available. Since the material is a cylinder type, it can be utilized for various purposes. A variety of products to meet the customers' needs, purposes, usage environments, and required performances are also available. We cover products from PTFE with filling materials to modified types that are strong to winding tiredness, such as glass fiber, carbon fiber, bronze, and products of special grade.
*Besides the sizes mentioned above, long pipes are also available. Please feel free to contact us.
*Please see information about the circular types here.


text:
//
// (C) Copyright 1998-1999 by Autodesk, Inc.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  AUTODESK, INC.
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
//
// Use, duplication, or disclosure by the U.S. Government is subject to
// restrictions set forth in FAR 52.227-19 (Commercial Computer
// Software - Restricted Rights) and DFAR 252.227-7013(c)(1)(ii)
// (Rights in Technical Data and Computer Software), as applicable.
//
//

#include "stdafx.h"
#include "ArxDbgLayoutManagerReactor.h"

ACRX_NO_CONS_DEFINE_MEMBERS(ArxDbgLayoutManagerReactor, AcDbLayoutManagerReactor);

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::ArxDbgLayoutManagerReactor
**
**  **jma
**
*************************************/

ArxDbgLayoutManagerReactor::ArxDbgLayoutManagerReactor()
{
	acdbHostApplicationServices()->layoutManager()->addReactor(this);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::~ArxDbgLayoutManagerReactor
**
**  **jma
**
*************************************/

ArxDbgLayoutManagerReactor::~ArxDbgLayoutManagerReactor()
{
	acdbHostApplicationServices()->layoutManager()->removeReactor(this);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutCreated
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutCreated(const char* newLayoutName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Layout Created"), newLayoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutToBeRemoved
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutToBeRemoved(const char* layoutName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Layout To Be Removed"), layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutRemoved
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutRemoved(const char* layoutName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Layout Removed"), layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::abortLayoutRemoved
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::abortLayoutRemoved(const char* layoutName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Abort Layout Removed"), layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutToBeCopied
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutToBeCopied(const char* layoutName, const AcDbObjectId& oldLayoutId)
{
	printReactorMessage(_T("Layout To Be Copied"), layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutCopied
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutCopied(const char* oldLayoutName,
				const AcDbObjectId& oldLayoutId,
				const char* newLayoutName,
				const AcDbObjectId& newLayoutId)
{
	printReactorMessage(_T("Layout Copied"), oldLayoutName, newLayoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::abortLayoutCopied
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::abortLayoutCopied(const char* layoutName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Abort Layout Copied"), layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutToBeRenamed
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutToBeRenamed(const char* oldName,
				const char* newName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Layout To Be Renamed"), oldName, newName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutRenamed
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutRenamed(const char* oldName,
				const char* newName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Layout Renamed"), oldName, newName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::abortLayoutRename
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::abortLayoutRename(const char* oldName,
				const char* newName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Abort Layout Rename"), oldName, newName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::layoutSwitched
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::layoutSwitched(const char* newLayoutname, const AcDbObjectId& newLayoutId)
{
	printReactorMessage(_T("Layout Switched"), newLayoutname);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::plotStyleTableChanged
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::plotStyleTableChanged(const char* newTableName, const AcDbObjectId& layoutId)
{
	printReactorMessage(_T("Plot Style Table Changed"), newTableName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::printReactorMessage
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::printReactorMessage(LPCTSTR event, const char* layoutName) const
{
    acutPrintf(_T("\n%-15s : [%s, \"%s\"] "), _T("[LAYOUT REACTOR]"), event, layoutName);
}

/****************************************************************************
**
**  ArxDbgLayoutManagerReactor::printReactorMessage
**
**  **jma
**
*************************************/

void
ArxDbgLayoutManagerReactor::printReactorMessage(LPCTSTR event, const char* layoutName1,
												const char* layoutName2) const
{
    acutPrintf(_T("\n%-15s : [%s, \"%s\" --> \"%s\"] "), _T("[LAYOUT REACTOR]"), event, layoutName1, layoutName2);
}

redpajama_set_name: RedPajamaGithub


Gazelle was founded in 1996 by Simon Willes as an FCA regulated specialist corporate finance firm with a successful track record advising on M&A transactions and debt restructuring. Led by Paul Thornton OBE, Gazelle Pensions Advisory was one of the first firms to provide covenant assessment following the Pensions Act 2004.
In 2012 Gazelle started development of an integrated risk model for DB pension schemes which resulted in Gazelle's Mousetrap integrated risk model becoming the first commercially available IRM model.
In 2016 and 2017 Gazelle was retained by the PLSA DB Task force to provide integrated risk modelling and associated input for the PLSA DB Task Force Reports. The Mousetrap model was also referred to in the 2016 DWP Green Paper on DB Pensions. These and associated articles and papers can be accessed below.


text:
Home * What's Happening This Month * Past Meetings and Events * Stone Barn * Links * Shop
History and Historic Sites of the Valley * Then and Now Photos * Lost Crescenta * Rockhaven * Membership and Donations
The History of Edendale
Monday June 20th, 7pm
at the Center for Spiritual Living
Long before "Hollywood" became synonymous with the commercial film industry, the area of Echo Park known as Edendale was the center of filmmaking on the West Coast. By the teens, several film studios were operating on Glendale Boulevard along the Echo Park-Silverlake border, including the Selig Polyscope Company, the Mack Sennett Studios, the Pathe West Coast Film Studio, and others.
Presented by Hollywood biographer and film historian Robert Birchard.
The first pie-in-the-face scene was filmed at what later became the Mack Sennett Studios on Glendale Boulevard, in the first purpose built filming studio, still in existence today as a storage facility.
Several silent film stars worked in the Edendale studios, including Mabel Normand, Fatty Arbuckle, Tom Mix and Harold Lloyd. Charlie Chaplin's first film was made in the Mack Sennett/Keystone Studios, and the iconic Keystone Cops got their start on the streets of Edendale.
Web Hosting sponsored by Caspian Services, Inc.

redpajama_set_name: RedPajamaCommonCrawl


text:
Privileged Access Management in SMBs + Recommendations
In the Devolutions State of IT Security in SMBs in 2022-23 survey [report now available!], we asked executives and decision-makers in SMBs to share how they are approaching, handling, and experiencing privileged access management (PAM) in their companies. Here is what we learned, the common challenge that many SMBs face, and what we recommend.
Key Findings from the Survey
Problems Using a Federated System
What SMBs Should Look for in a Robust PAM Solution
Benefits of Fully Implementing a PAM Solution
98% of SMBs are managing privileged accounts. However, only 12% have a fully-deployed PAM solution in place — which means that 88% are less secure and more vulnerable than they believe. And even more alarming is that 52% of SMBs have not implemented any PAM controls at all!
The two most common reasons why the majority of SMBs do not have a fully-deployed PAM solution in place are that they do not have enough budget (28%), and that PAM is too complex to implement and manage (12%).
The three most important features that SMBs want in a PAM solution are: automatically expiring privileged access, built-in MFA, and password rotation reset.
15% of SMBs credit PAM controls for enhancing their approval workflow, improving productivity, and overall accelerating the velocity of work. A further 22% of SMBs did not experience any post-PAM impact (negative or positive), and 11% said that they experienced some drawbacks.
To protect the valuable data and assets in their privileged accounts — a.k.a. "the keys to the kingdom" — SMBs need to establish and enforce both parts of the Identity and Access Management equation:
Identity management is concerned with WHO an end user is.
Access management is concerned with WHAT an end-user is authorized to do.
However, a common challenge is that certain technologies — such as legacy systems, phones, and cameras — cannot use a federated system.
So why don't SMBs solve this by manually creating and maintaining unique identity accounts for each user? While this is technically possible, in reality it is highly impractical considering the volume of different privileged account types that typically exist in the ecosystem, such as:
Domain Administrator Accounts
Local Administrator Accounts
Emergency Access Accounts
Application Accounts
System Accounts
Domain Service Accounts
Fortunately, there is a proven solution to this challenge: SMBs should fully implement a PAM solution that bridges the gap between authentication and authorization, and extends the protection offered by an IAM system into the non-federated identity space.
SMBs should focus on a robust PAM solution that offers all of the following:
A vault that stores passwords (and other sensitive data, such as building alarm codes, software license keys, etc.), and which is securely shared between multiple end-users.
Account checkout, which allows Admins to grant or reject an access request on a case-by-case basis, and if necessary, set time limits.
Notifications that alert Admins when certain events or actions take place involving end users, roles, vaults, etc.
Automated mandatory password rotation.
Account brokering, which automates workflows (e.g., opening a VPN client, launching a remote access protocol, and accessing a privileged account) without providing end-users with passwords in the first place.
Session activity recording.
Enables credential rotation on and after every check-out for an RDP session, which mitigates the potential exploitation of the RDP credentials (credentials do not need to be passed to users, as each authentication occurs one time — thereby eliminating the need to rotate credentials).
Ease-of-deployment and management.
Affordably priced to suit SMB IT security budgets, which are significantly smaller than large enterprise budgets.
In addition to the above, some more sophisticated PAM solutions support privileged session management (PSM), which utilizes a specialized server that brokers authentication behind-the-scenes, and can also record the activity of remote sessions. PSM is especially important for SMBs that have contractors and "boomerang" employees (i.e., employees who leave the organization and then return). These end users typically need more scrutiny and limited access.
By fully implementing a robust PAM solution, SMBs will effectively and sustainably:
Reduce security risks.
Shrink the overall size of the attack surface.
Lower operational costs and complexity.
Increase visibility and situational awareness.
Improve regulatory compliance.
In our next deep dive into the Devolutions State of IT Security in SMBs in 2022-23 Survey report, we will look at how SMBs are prioritizing, implementing, and measuring efforts to improve IT security awareness, and how they can improve this area to strengthen the "weakest link" in the IT security defense chain: end users.


text:
/**
  * @author Kai Salmen / https://kaisalmen.de
  * Development repository: https://github.com/kaisalmen/WWOBJLoader
  */

'use strict';

if ( THREE.OBJLoader2 === undefined ) { THREE.OBJLoader2 = {} }

if ( THREE.LoaderSupport === undefined ) console.error( '"THREE.LoaderSupport" is not available. "THREE.OBJLoader2" requires it. Please include "LoaderSupport.js" in your HTML.' );

/**
 * Use this class to load OBJ data from files or to parse OBJ data from an arraybuffer
 * @class
 *
 * @param {THREE.DefaultLoadingManager} [manager] The loadingManager for the loader to use. Default is {@link THREE.DefaultLoadingManager}
 * @param {THREE.LoaderSupport.ConsoleLogger} logger logger to be used
 */
THREE.OBJLoader2 = (function () {

	var OBJLOADER2_VERSION = '2.3.1';
	var Validator = THREE.LoaderSupport.Validator;

	OBJLoader2.prototype = Object.create( THREE.LoaderSupport.LoaderBase.prototype );
	OBJLoader2.prototype.constructor = OBJLoader2;

	function OBJLoader2( manager, logger ) {
		THREE.LoaderSupport.LoaderBase.call( this, manager, logger );
		this.logger.logInfo( 'Using THREE.OBJLoader2 version: ' + OBJLOADER2_VERSION );

		this.materialPerSmoothingGroup = false;

		this.workerSupport = null;
		this.terminateWorkerOnLoad = true;
	}

	/**
	 * Tells whether a material shall be created per smoothing group.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {boolean} materialPerSmoothingGroup=false
	 */
	OBJLoader2.prototype.setMaterialPerSmoothingGroup = function ( materialPerSmoothingGroup ) {
		this.materialPerSmoothingGroup = materialPerSmoothingGroup === true;
	};

	/**
	 * Run the loader according the provided instructions.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {THREE.LoaderSupport.PrepData} prepData All parameters and resources required for execution
	 * @param {THREE.LoaderSupport.WorkerSupport} [workerSupportExternal] Use pre-existing WorkerSupport
	 */
	OBJLoader2.prototype.run = function ( prepData, workerSupportExternal ) {
		this._applyPrepData( prepData );
		var available = this.checkResourceDescriptorFiles( prepData.resources,
			[
				{ ext: "obj", type: "Uint8Array", ignore: false },
				{ ext: "mtl", type: "String", ignore: false },
				{ ext: "zip", type: "String", ignore: true }
			]
		);
		if ( Validator.isValid( workerSupportExternal ) ) {

			this.terminateWorkerOnLoad = false;
			this.workerSupport = workerSupportExternal;
			this.logger = workerSupportExternal.logger;

		}
		var scope = this;
		var onMaterialsLoaded = function ( materials ) {
			scope.builder.setMaterials( materials );

			if ( Validator.isValid( available.obj.content ) ) {

				if ( prepData.useAsync ) {

					scope.parseAsync( available.obj.content, scope.callbacks.onLoad );

				} else {

					scope.parse( available.obj.content );

				}
			} else {

				scope.setPath( available.obj.path );
				scope.load( available.obj.name, scope.callbacks.onLoad, null, null, scope.callbacks.onMeshAlter, prepData.useAsync );

			}
		};

		this._loadMtl( available.mtl, onMaterialsLoaded, prepData.crossOrigin );
	};

	OBJLoader2.prototype._applyPrepData = function ( prepData ) {
		THREE.LoaderSupport.LoaderBase.prototype._applyPrepData.call( this, prepData );

		if ( Validator.isValid( prepData ) ) {

			this.setMaterialPerSmoothingGroup( prepData.materialPerSmoothingGroup );

		}
	};

	/**
	 * Parses OBJ data synchronously from arraybuffer or string.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {arraybuffer|string} content OBJ data as Uint8Array or String
	 */
	OBJLoader2.prototype.parse = function ( content ) {
		this.logger.logTimeStart( 'OBJLoader2 parse: ' + this.modelName );

		var parser = new Parser();
		parser.setLogConfig( this.logger.enabled, this.logger.debug );
		parser.setMaterialPerSmoothingGroup( this.materialPerSmoothingGroup );
		parser.setUseIndices( this.useIndices );
		parser.setDisregardNormals( this.disregardNormals );
		// sync code works directly on the material references
		parser.setMaterials( this.builder.getMaterials() );

		var scope = this;
		var onMeshLoaded = function ( payload ) {
			var meshes = scope.builder.processPayload( payload );
			var mesh;
			for ( var i in meshes ) {
				mesh = meshes[ i ];
				scope.loaderRootNode.add( mesh );
			}
		};
		parser.setCallbackBuilder( onMeshLoaded );
		var onProgressScoped = function ( text, numericalValue ) {
			scope.onProgress( 'progressParse', text, numericalValue );
		};
		parser.setCallbackProgress( onProgressScoped );

		if ( content instanceof ArrayBuffer || content instanceof Uint8Array ) {

			this.logger.logInfo( 'Parsing arrayBuffer...' );
			parser.parse( content );

		} else if ( typeof( content ) === 'string' || content instanceof String ) {

			this.logger.logInfo( 'Parsing text...' );
			parser.parseText( content );

		} else {

			throw 'Provided content was neither of type String nor Uint8Array! Aborting...';

		}
		this.logger.logTimeEnd( 'OBJLoader2 parse: ' + this.modelName );

		return this.loaderRootNode;
	};

	/**
	 * Parses OBJ content asynchronously from arraybuffer.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {arraybuffer} content OBJ data as Uint8Array
	 * @param {callback} onLoad Called after worker successfully completed loading
	 */
	OBJLoader2.prototype.parseAsync = function ( content, onLoad ) {
		this.logger.logTimeStart( 'OBJLoader2 parseAsync: ' + this.modelName );

		var scope = this;
		var scopedOnLoad = function () {
			onLoad(
				{
					detail: {
						loaderRootNode: scope.loaderRootNode,
						modelName: scope.modelName,
						instanceNo: scope.instanceNo
					}
				}
			);
			scope.logger.logTimeEnd( 'OBJLoader2 parseAsync: ' + scope.modelName );
		};
		var scopedOnMeshLoaded = function ( payload ) {
			var meshes = scope.builder.processPayload( payload );
			var mesh;
			for ( var i in meshes ) {
				mesh = meshes[ i ];
				scope.loaderRootNode.add( mesh );
			}
		};

		this.workerSupport = Validator.verifyInput( this.workerSupport, new THREE.LoaderSupport.WorkerSupport( this.logger ) );
		var buildCode = function ( funcBuildObject, funcBuildSingleton ) {
			var workerCode = '';
			workerCode += '/**\n';
			workerCode += '  * This code was constructed by OBJLoader2 buildCode.\n';
			workerCode += '  */\n\n';
			workerCode += 'THREE = { LoaderSupport: {} };\n\n';
			workerCode += funcBuildObject( 'THREE.LoaderSupport.Validator', Validator );
			workerCode += funcBuildSingleton( 'THREE.LoaderSupport.ConsoleLogger', THREE.LoaderSupport.ConsoleLogger );
			workerCode += funcBuildSingleton( 'THREE.LoaderSupport.LoaderBase', THREE.LoaderSupport.LoaderBase );
			workerCode += funcBuildSingleton( 'Parser', Parser );

			return workerCode;
		};
		this.workerSupport.validate( buildCode, 'Parser' );
		this.workerSupport.setCallbacks( scopedOnMeshLoaded, scopedOnLoad );
		if ( scope.terminateWorkerOnLoad ) this.workerSupport.setTerminateRequested( true );

		var materialNames = {};
		var materials = this.builder.getMaterials();
		for ( var materialName in materials ) {

			materialNames[ materialName ] = materialName;

		}
		this.workerSupport.run(
			{
				params: {
					useAsync: true,
					materialPerSmoothingGroup: this.materialPerSmoothingGroup,
					useIndices: this.useIndices,
					disregardNormals: this.disregardNormals
				},
				logger: {
					debug: this.logger.debug,
					enabled: this.logger.enabled
				},
				materials: {
					// in async case only material names are supplied to parser
					materials: materialNames
				},
				data: {
					input: content,
					options: null
				}
			}
		);
	};

	/**
	 * Parse OBJ data either from ArrayBuffer or string
	 * @class
	 */
	var Parser = (function () {

		function Parser() {
			this.callbackProgress = null;
			this.callbackBuilder = null;

			this.materials = {};
			this.useAsync = false;
			this.materialPerSmoothingGroup = false;
			this.useIndices = false;
			this.disregardNormals = false;

			this.vertices = [];
			this.colors = [];
			this.normals = [];
			this.uvs = [];

			this.rawMesh = {
				objectName: '',
				groupName: '',
				activeMtlName: '',
				mtllibName: '',

				// reset with new mesh
				faceType: -1,
				subGroups: [],
				subGroupInUse: null,
				smoothingGroup: {
					splitMaterials: false,
					normalized: -1,
					real: -1
				},
				counts: {
					doubleIndicesCount: 0,
					faceCount: 0,
					mtlCount: 0,
					smoothingGroupCount: 0
				}
			};

			this.inputObjectCount = 1;
			this.outputObjectCount = 1;
			this.globalCounts = {
				vertices: 0,
				faces: 0,
				doubleIndicesCount: 0,
				currentByte: 0,
				totalBytes: 0
			};
			this.logger = new THREE.LoaderSupport.ConsoleLogger();
		}

		Parser.prototype.resetRawMesh = function () {
			// faces are stored according combined index of group, material and smoothingGroup (0 or not)
			this.rawMesh.subGroups = [];
			this.rawMesh.subGroupInUse = null;
			this.rawMesh.smoothingGroup.normalized = -1;
			this.rawMesh.smoothingGroup.real = -1;

			// this default index is required as it is possible to define faces without 'g' or 'usemtl'
			this.pushSmoothingGroup( 1 );

			this.rawMesh.counts.doubleIndicesCount = 0;
			this.rawMesh.counts.faceCount = 0;
			this.rawMesh.counts.mtlCount = 0;
			this.rawMesh.counts.smoothingGroupCount = 0;
		};

		Parser.prototype.setUseAsync = function ( useAsync ) {
			this.useAsync = useAsync;
		};

		Parser.prototype.setMaterialPerSmoothingGroup = function ( materialPerSmoothingGroup ) {
			this.materialPerSmoothingGroup = materialPerSmoothingGroup;
		};

		Parser.prototype.setUseIndices = function ( useIndices ) {
			this.useIndices = useIndices;
		};

		Parser.prototype.setDisregardNormals = function ( disregardNormals ) {
			this.disregardNormals = disregardNormals;
		};

		Parser.prototype.setMaterials = function ( materials ) {
			this.materials = THREE.LoaderSupport.Validator.verifyInput( materials, this.materials );
			this.materials = THREE.LoaderSupport.Validator.verifyInput( this.materials, {} );
		};

		Parser.prototype.setCallbackBuilder = function ( callbackBuilder ) {
			if ( ! THREE.LoaderSupport.Validator.isValid( callbackBuilder ) ) throw 'Unable to run as no "builder" callback is set.';
			this.callbackBuilder = callbackBuilder;
		};

		Parser.prototype.setCallbackProgress = function ( callbackProgress ) {
			this.callbackProgress = callbackProgress;
		};

		Parser.prototype.setLogConfig = function ( enabled, debug ) {
			this.logger.setEnabled( enabled );
			this.logger.setDebug( debug );
		};

		Parser.prototype.configure = function () {
			this.pushSmoothingGroup( 1 );

			if ( this.logger.isEnabled() ) {

				var matKeys = Object.keys( this.materials );
				var matNames = ( matKeys.length > 0 ) ? '\n\tmaterialNames:\n\t\t- ' + matKeys.join( '\n\t\t- ' ) : '\n\tmaterialNames: None';
				var printedConfig = 'OBJLoader2.Parser configuration:'
					+ matNames
					+ '\n\tuseAsync: ' + this.useAsync
					+ '\n\tmaterialPerSmoothingGroup: ' + this.materialPerSmoothingGroup
					+ '\n\tuseIndices: ' + this.useIndices
					+ '\n\tdisregardNormals: ' + this.disregardNormals
					+ '\n\tcallbackBuilderName: ' + this.callbackBuilder.name
					+ '\n\tcallbackProgressName: ' + this.callbackProgress.name;
				this.logger.logInfo( printedConfig );
			}
		};

		/**
		 * Parse the provided arraybuffer
		 * @memberOf Parser
		 *
		 * @param {Uint8Array} arrayBuffer OBJ data as Uint8Array
		 */
		Parser.prototype.parse = function ( arrayBuffer ) {
			this.logger.logTimeStart( 'OBJLoader2.Parser.parse' );
			this.configure();

			var arrayBufferView = new Uint8Array( arrayBuffer );
			var length = arrayBufferView.byteLength;
			this.globalCounts.totalBytes = length;
			var buffer = new Array( 128 );
			var bufferPointer = 0;
			var slashSpacePattern = new Array( 16 );
			var slashSpacePatternPointer = 0;
			var code;
			var word = '';
			var i = 0;
			for ( ; i < length; i++ ) {

				code = arrayBufferView[ i ];
				switch ( code ) {
					// space
					case 32:
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						slashSpacePattern[ slashSpacePatternPointer++ ] = 0;
						word = '';
						break;
					// slash
					case 47:
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						slashSpacePattern[ slashSpacePatternPointer++ ] = 1;
						word = '';
						break;

					// LF
					case 10:
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						word = '';
						this.globalCounts.currentByte = i;
						this.processLine( buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer );
						bufferPointer = 0;
						slashSpacePatternPointer = 0;
						break;

					// CR
					case 13:
						break;

					default:
						word += String.fromCharCode( code );
						break;
				}
			}
			this.finalizeParsing();
			this.logger.logTimeEnd( 'OBJLoader2.Parser.parse' );
		};

		/**
		 * Parse the provided text
		 * @memberOf Parser
		 *
		 * @param {string} text OBJ data as string
		 */
		Parser.prototype.parseText = function ( text ) {
			this.logger.logTimeStart( 'OBJLoader2.Parser.parseText' );
			this.configure();

			var length = text.length;
			this.globalCounts.totalBytes = length;
			var buffer = new Array( 128 );
			var bufferPointer = 0;
			var slashSpacePattern = new Array( 16 );
			var slashSpacePatternPointer = 0;
			var char;
			var word = '';
			var i = 0;
			for ( ; i < length; i++ ) {

				char = text[ i ];
				switch ( char ) {
					case ' ':
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						slashSpacePattern[ slashSpacePatternPointer++ ] = 0;
						word = '';
						break;

					case '/':
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						slashSpacePattern[ slashSpacePatternPointer++ ] = 1;
						word = '';
						break;

					case '\n':
						if ( word.length > 0 ) buffer[ bufferPointer++ ] = word;
						word = '';
						this.globalCounts.currentByte = i;
						this.processLine( buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer );
						bufferPointer = 0;
						slashSpacePatternPointer = 0;
						break;

					case '\r':
						break;

					default:
						word += char;
				}
			}
			this.finalizeParsing();
			this.logger.logTimeEnd( 'OBJLoader2.Parser.parseText' );
		};

		Parser.prototype.processLine = function ( buffer, bufferPointer, slashSpacePattern, slashSpacePatternPointer ) {
			if ( bufferPointer < 1 ) return;

			var countSlashes = function ( slashSpacePattern, slashSpacePatternPointer ) {
				var slashesCount = 0;
				for ( var i = 0; i < slashSpacePatternPointer; i++ ) {
					slashesCount += slashSpacePattern[ i ];
				}
				return slashesCount;
			};

			var concatStringBuffer = function ( buffer, bufferPointer, slashSpacePattern ) {
				var concatBuffer = '';
				if ( bufferPointer === 2 ) {

					concatBuffer = buffer[ 1 ];

				} else {

					var bufferLength = bufferPointer - 1;
					for ( var i = 1; i < bufferLength; i++ ) {

						concatBuffer += buffer[ i ] + ( slashSpacePattern[ i ] === 0 ? ' ' : '/' );

					}
					concatBuffer += buffer[ bufferLength ];

				}
				return concatBuffer;
			};

			var flushStringBuffer = function ( buffer, bufferPointer ) {
				for ( var i = 0; i < bufferPointer; i++ ) {
					buffer[ i ] = '';
				}
			};

			switch ( buffer[ 0 ] ) {
				case 'v':
					this.vertices.push( parseFloat( buffer[ 1 ] ) );
					this.vertices.push( parseFloat( buffer[ 2 ] ) );
					this.vertices.push( parseFloat( buffer[ 3 ] ) );
					if ( bufferPointer > 4 ) {

						this.colors.push( parseFloat( buffer[ 4 ] ) );
						this.colors.push( parseFloat( buffer[ 5 ] ) );
						this.colors.push( parseFloat( buffer[ 6 ] ) );

					}
					break;

				case 'vt':
					this.uvs.push( parseFloat( buffer[ 1 ] ) );
					this.uvs.push( parseFloat( buffer[ 2 ] ) );
					break;

				case 'vn':
					this.normals.push( parseFloat( buffer[ 1 ] ) );
					this.normals.push( parseFloat( buffer[ 2 ] ) );
					this.normals.push( parseFloat( buffer[ 3 ] ) );
					break;

				case 'f':
					var slashesCount = countSlashes( slashSpacePattern, slashSpacePatternPointer );
					var bufferLength = bufferPointer - 1;

					// "f vertex ..."
					if ( slashesCount === 0 ) {

						this.checkFaceType( 0 );

						// "f vertex/uv ..."
					} else if  ( bufferLength === slashesCount * 2 ) {

						this.checkFaceType( 1 );

						// "f vertex/uv/normal ..."
					} else if  ( bufferLength * 2 === slashesCount * 3 ) {

						this.checkFaceType( 2 );

						// "f vertex//normal ..."
					} else {

						this.checkFaceType( 3 );

					}
					this.processFaces( buffer, bufferLength );
					break;

				case 'l':
					this.checkFaceType( 4 );
					this.processLinesOrPoints( buffer, bufferPointer, countSlashes( slashSpacePattern, slashSpacePatternPointer ) );
					break;

				case 'p':
					this.checkFaceType( 5 );
					this.processLinesOrPoints( buffer, bufferPointer, 0 );
					break;

				case 's':
					this.pushSmoothingGroup( buffer[ 1 ] );
					flushStringBuffer( buffer, bufferPointer );
					break;

				case 'g':
					// 'g' leads to creation of mesh if valid data (faces declaration was done before), otherwise only groupName gets set
					this.processCompletedMesh();
					this.rawMesh.groupName = THREE.LoaderSupport.Validator.verifyInput( concatStringBuffer( buffer, bufferPointer, slashSpacePattern ), '' );
					flushStringBuffer( buffer, bufferPointer );
					break;

				case 'o':
					// 'o' is pure meta-information and does not result in creation of new meshes
					this.rawMesh.objectName = THREE.LoaderSupport.Validator.verifyInput( concatStringBuffer( buffer, bufferPointer, slashSpacePattern ), '' );
					flushStringBuffer( buffer, bufferPointer );
					break;

				case 'mtllib':
					this.rawMesh.mtllibName = THREE.LoaderSupport.Validator.verifyInput( concatStringBuffer( buffer, bufferPointer, slashSpacePattern ), '' );
					flushStringBuffer( buffer, bufferPointer );
					break;

				case 'usemtl':
					var mtlName = concatStringBuffer( buffer, bufferPointer, slashSpacePattern );
					if ( this.rawMesh.activeMtlName !== mtlName && THREE.LoaderSupport.Validator.isValid( mtlName ) ) {

						this.rawMesh.activeMtlName = mtlName;
						this.rawMesh.counts.mtlCount++;
						this.checkSubGroup();

					}
					flushStringBuffer( buffer, bufferPointer );
					break;

				default:
					break;
			}
		};

		Parser.prototype.pushSmoothingGroup = function ( smoothingGroup ) {
			var smoothingGroupInt = parseInt( smoothingGroup );
			if ( isNaN( smoothingGroupInt ) ) {
				smoothingGroupInt = smoothingGroup === "off" ? 0 : 1;
			}

			var smoothCheck = this.rawMesh.smoothingGroup.normalized;
			this.rawMesh.smoothingGroup.normalized = this.rawMesh.smoothingGroup.splitMaterials ? smoothingGroupInt : ( smoothingGroupInt === 0 ) ? 0 : 1;
			this.rawMesh.smoothingGroup.real = smoothingGroupInt;

			if ( smoothCheck !== smoothingGroupInt ) {

				this.rawMesh.counts.smoothingGroupCount++;
				this.checkSubGroup();

			}
		};

		/**
		 * Expanded faceTypes include all four face types, both line types and the point type
		 * faceType = 0: "f vertex ..."
		 * faceType = 1: "f vertex/uv ..."
		 * faceType = 2: "f vertex/uv/normal ..."
		 * faceType = 3: "f vertex//normal ..."
		 * faceType = 4: "l vertex/uv ..." or "l vertex ..."
		 * faceType = 5: "p vertex ..."
		 */
		Parser.prototype.checkFaceType = function ( faceType ) {
			if ( this.rawMesh.faceType !== faceType ) {

				this.processCompletedMesh();
				this.rawMesh.faceType = faceType;
				this.checkSubGroup();

			}
		};

		Parser.prototype.checkSubGroup = function () {
			var index = this.rawMesh.activeMtlName + '|' + this.rawMesh.smoothingGroup.normalized;
			this.rawMesh.subGroupInUse = this.rawMesh.subGroups[ index ];

			if ( ! THREE.LoaderSupport.Validator.isValid( this.rawMesh.subGroupInUse ) ) {

				this.rawMesh.subGroupInUse = {
					index: index,
					objectName: this.rawMesh.objectName,
					groupName: this.rawMesh.groupName,
					materialName: this.rawMesh.activeMtlName,
					smoothingGroup: this.rawMesh.smoothingGroup.normalized,
					vertices: [],
					indexMappingsCount: 0,
					indexMappings: [],
					indices: [],
					colors: [],
					uvs: [],
					normals: []
				};
				this.rawMesh.subGroups[ index ] = this.rawMesh.subGroupInUse;

			}
		};

		Parser.prototype.processFaces = function ( buffer, bufferLength ) {
			var i, length;

			// "f vertex ..."
			if ( this.rawMesh.faceType === 0 ) {

				for ( i = 2, length = bufferLength; i < length; i ++ ) {

					this.buildFace( buffer[ 1 ] );
					this.buildFace( buffer[ i ] );
					this.buildFace( buffer[ i + 1 ] );

				}

				// "f vertex/uv ..."
			} else if  ( this.rawMesh.faceType === 1 ) {

				for ( i = 3, length = bufferLength - 2; i < length; i += 2 ) {

					this.buildFace( buffer[ 1 ], buffer[ 2 ] );
					this.buildFace( buffer[ i ], buffer[ i + 1 ] );
					this.buildFace( buffer[ i + 2 ], buffer[ i + 3 ] );

				}

				// "f vertex/uv/normal ..."
			} else if  ( this.rawMesh.faceType === 2 ) {

				for ( i = 4, length = bufferLength - 3; i < length; i += 3 ) {

					this.buildFace( buffer[ 1 ], buffer[ 2 ], buffer[ 3 ] );
					this.buildFace( buffer[ i ], buffer[ i + 1 ], buffer[ i + 2 ] );
					this.buildFace( buffer[ i + 3 ], buffer[ i + 4 ], buffer[ i + 5 ] );

				}

				// "f vertex//normal ..."
			} else {

				for ( i = 3, length = bufferLength - 2; i < length; i += 2 ) {

					this.buildFace( buffer[ 1 ], undefined, buffer[ 2 ] );
					this.buildFace( buffer[ i ], undefined, buffer[ i + 1 ] );
					this.buildFace( buffer[ i + 2 ], undefined, buffer[ i + 3 ] );

				}

			}
		};

		Parser.prototype.buildFace = function ( faceIndexV, faceIndexU, faceIndexN ) {
			if ( this.disregardNormals ) faceIndexN = undefined;
			var scope = this;
			var updateSubGroupInUse = function () {

				var faceIndexVi = parseInt( faceIndexV );
				var indexPointerV = 3 * ( faceIndexVi > 0 ? faceIndexVi - 1 : faceIndexVi + scope.vertices.length / 3 );

				var vertices = scope.rawMesh.subGroupInUse.vertices;
				vertices.push( scope.vertices[ indexPointerV++ ] );
				vertices.push( scope.vertices[ indexPointerV++ ] );
				vertices.push( scope.vertices[ indexPointerV ] );

				var indexPointerC = scope.colors.length > 0 ? indexPointerV : null;
				if ( indexPointerC !== null ) {

					var colors = scope.rawMesh.subGroupInUse.colors;
					colors.push( scope.colors[ indexPointerC++ ] );
					colors.push( scope.colors[ indexPointerC++ ] );
					colors.push( scope.colors[ indexPointerC ] );

				}

				if ( faceIndexU ) {

					var faceIndexUi = parseInt( faceIndexU );
					var indexPointerU = 2 * ( faceIndexUi > 0 ? faceIndexUi - 1 : faceIndexUi + scope.uvs.length / 2 );
					var uvs = scope.rawMesh.subGroupInUse.uvs;
					uvs.push( scope.uvs[ indexPointerU++ ] );
					uvs.push( scope.uvs[ indexPointerU ] );

				}
				if ( faceIndexN ) {

					var faceIndexNi = parseInt( faceIndexN );
					var indexPointerN = 3 * ( faceIndexNi > 0 ? faceIndexNi - 1 : faceIndexNi + scope.normals.length / 3 );
					var normals = scope.rawMesh.subGroupInUse.normals;
					normals.push( scope.normals[ indexPointerN++ ] );
					normals.push( scope.normals[ indexPointerN++ ] );
					normals.push( scope.normals[ indexPointerN ] );

				}
			};

			if ( this.useIndices ) {

				var mappingName = faceIndexV + ( faceIndexU ? '_' + faceIndexU : '_n' ) + ( faceIndexN ? '_' + faceIndexN : '_n' );
				var indicesPointer = this.rawMesh.subGroupInUse.indexMappings[ mappingName ];
				if ( THREE.LoaderSupport.Validator.isValid( indicesPointer ) ) {

					this.rawMesh.counts.doubleIndicesCount++;

				} else {

					indicesPointer = this.rawMesh.subGroupInUse.vertices.length / 3;
					updateSubGroupInUse();
					this.rawMesh.subGroupInUse.indexMappings[ mappingName ] = indicesPointer;
					this.rawMesh.subGroupInUse.indexMappingsCount++;

				}
				this.rawMesh.subGroupInUse.indices.push( indicesPointer );

			} else {

				updateSubGroupInUse();

			}
			this.rawMesh.counts.faceCount++;
		};

		/*
		 * Support for lines with or without texture or Points (just Vertex).
		 * First element in indexArray is the line/point identification
		 *
		 * : "l vertex/uv		vertex/uv 		..."
		 * 1: "l vertex			vertex 			..."
		 */
		Parser.prototype.processLinesOrPoints = function ( buffer, bufferPointer, slashCount ) {
			var i = 1;
			var length;
			var bufferLength = bufferPointer - 1;

			if ( bufferLength === slashCount * 2 ) {

				for ( length = bufferPointer; i < length; i += 2 ) this.buildFace( buffer[ i ], buffer[ i + 1 ] );

			} else {

				for ( length = bufferPointer; i < length; i ++ ) this.buildFace( buffer[ i ] );

			}
		};

		Parser.prototype.createRawMeshReport = function ( inputObjectCount ) {
			return 'Input Object number: ' + inputObjectCount +
				'\n\tObject name: ' + this.rawMesh.objectName +
				'\n\tGroup name: ' + this.rawMesh.groupName +
				'\n\tMtllib name: ' + this.rawMesh.mtllibName +
				'\n\tVertex count: ' + this.vertices.length / 3 +
				'\n\tNormal count: ' + this.normals.length / 3 +
				'\n\tUV count: ' + this.uvs.length / 2 +
				'\n\tSmoothingGroup count: ' + this.rawMesh.counts.smoothingGroupCount +
				'\n\tMaterial count: ' + this.rawMesh.counts.mtlCount +
				'\n\tReal MeshOutputGroup count: ' + this.rawMesh.subGroups.length;
		};

		/**
		 * Clear any empty subGroup and calculate absolute vertex, normal and uv counts
		 */
		Parser.prototype.finalizeRawMesh = function () {
			var meshOutputGroupTemp = [];
			var meshOutputGroup;
			var absoluteVertexCount = 0;
			var absoluteIndexMappingsCount = 0;
			var absoluteIndexCount = 0;
			var absoluteColorCount = 0;
			var absoluteNormalCount = 0;
			var absoluteUvCount = 0;
			var indices;
			for ( var name in this.rawMesh.subGroups ) {

				meshOutputGroup = this.rawMesh.subGroups[ name ];
				if ( meshOutputGroup.vertices.length > 0 ) {

					indices = meshOutputGroup.indices;
					if ( indices.length > 0 && absoluteIndexMappingsCount > 0 ) {

						for ( var i in indices ) indices[ i ] = indices[ i ] + absoluteIndexMappingsCount;

					}
					meshOutputGroupTemp.push( meshOutputGroup );
					absoluteVertexCount += meshOutputGroup.vertices.length;
					absoluteIndexMappingsCount += meshOutputGroup.indexMappingsCount;
					absoluteIndexCount += meshOutputGroup.indices.length;
					absoluteColorCount += meshOutputGroup.colors.length;
					absoluteUvCount += meshOutputGroup.uvs.length;
					absoluteNormalCount += meshOutputGroup.normals.length;

				}
			}

			// do not continue if no result
			var result = null;
			if ( meshOutputGroupTemp.length > 0 ) {

				result = {
					name: this.rawMesh.groupName !== '' ? this.rawMesh.groupName : this.rawMesh.objectName,
					subGroups: meshOutputGroupTemp,
					absoluteVertexCount: absoluteVertexCount,
					absoluteIndexCount: absoluteIndexCount,
					absoluteColorCount: absoluteColorCount,
					absoluteNormalCount: absoluteNormalCount,
					absoluteUvCount: absoluteUvCount,
					faceCount: this.rawMesh.counts.faceCount,
					doubleIndicesCount: this.rawMesh.counts.doubleIndicesCount
				};

			}
			return result;
		};

		Parser.prototype.processCompletedMesh = function () {
			var result = this.finalizeRawMesh();
			if ( THREE.LoaderSupport.Validator.isValid( result ) ) {

				if ( this.colors.length > 0 && this.colors.length !== this.vertices.length ) {

					throw 'Vertex Colors were detected, but vertex count and color count do not match!';

				}
				if ( this.logger.isDebug() ) this.logger.logDebug( this.createRawMeshReport( this.inputObjectCount ) );
				this.inputObjectCount++;

				this.buildMesh( result );
				var progressBytesPercent = this.globalCounts.currentByte / this.globalCounts.totalBytes;
				this.callbackProgress( 'Completed [o: ' + this.rawMesh.objectName + ' g:' + this.rawMesh.groupName + '] Total progress: ' + ( progressBytesPercent * 100 ).toFixed( 2 ) + '%', progressBytesPercent );
				this.resetRawMesh();
				return true;

			} else {

				return false;
			}
		};

		/**
		 * SubGroups are transformed to too intermediate format that is forwarded to the Builder.
		 * It is ensured that SubGroups only contain objects with vertices (no need to check).
		 *
		 * @param result
		 */
		Parser.prototype.buildMesh = function ( result ) {
			var meshOutputGroups = result.subGroups;

			var vertexFA = new Float32Array( result.absoluteVertexCount );
			this.globalCounts.vertices += result.absoluteVertexCount / 3;
			this.globalCounts.faces += result.faceCount;
			this.globalCounts.doubleIndicesCount += result.doubleIndicesCount;
			var indexUA = ( result.absoluteIndexCount > 0 ) ? new Uint32Array( result.absoluteIndexCount ) : null;
			var colorFA = ( result.absoluteColorCount > 0 ) ? new Float32Array( result.absoluteColorCount ) : null;
			var normalFA = ( result.absoluteNormalCount > 0 ) ? new Float32Array( result.absoluteNormalCount ) : null;
			var uvFA = ( result.absoluteUvCount > 0 ) ? new Float32Array( result.absoluteUvCount ) : null;
			var haveVertexColors = THREE.LoaderSupport.Validator.isValid( colorFA );

			var meshOutputGroup;
			var materialNames = [];

			var createMultiMaterial = ( meshOutputGroups.length > 1 );
			var materialIndex = 0;
			var materialIndexMapping = [];
			var selectedMaterialIndex;
			var materialGroup;
			var materialGroups = [];

			var vertexFAOffset = 0;
			var indexUAOffset = 0;
			var colorFAOffset = 0;
			var normalFAOffset = 0;
			var uvFAOffset = 0;
			var materialGroupOffset = 0;
			var materialGroupLength = 0;

			var materialOrg, material, materialName, materialNameOrg;
			// only one specific face type
			for ( var oodIndex in meshOutputGroups ) {

				if ( ! meshOutputGroups.hasOwnProperty( oodIndex ) ) continue;
				meshOutputGroup = meshOutputGroups[ oodIndex ];

				materialNameOrg = meshOutputGroup.materialName;
				if ( this.rawMesh.faceType < 4 ) {

					materialName = materialNameOrg + ( haveVertexColors ? '_vertexColor' : '' ) + ( meshOutputGroup.smoothingGroup === 0 ? '_flat' : '' );

				} else {

					materialName = this.rawMesh.faceType === 4 ? 'defaultLineMaterial' : 'defaultPointMaterial';

				}
				materialOrg = this.materials[ materialNameOrg ];
				material = this.materials[ materialName ];

				// both original and derived names do not lead to an existing material => need to use a default material
				if ( ! THREE.LoaderSupport.Validator.isValid( materialOrg ) && ! THREE.LoaderSupport.Validator.isValid( material ) ) {

					var defaultMaterialName = haveVertexColors ? 'defaultVertexColorMaterial' : 'defaultMaterial';
					materialOrg = this.materials[ defaultMaterialName ];
					this.logger.logWarn( 'object_group "' + meshOutputGroup.objectName + '_' +
						meshOutputGroup.groupName + '" was defined with unresolvable material "' +
						materialNameOrg + '"! Assigning "' + defaultMaterialName + '".' );
					materialNameOrg = defaultMaterialName;

					// if names are identical then there is no need for later manipulation
					if ( materialNameOrg === materialName ) {

						material = materialOrg;
						materialName = defaultMaterialName;

					}

				}
				if ( ! THREE.LoaderSupport.Validator.isValid( material ) ) {

					var materialCloneInstructions = {
						materialNameOrg: materialNameOrg,
						materialName: materialName,
						materialProperties: {
							vertexColors: haveVertexColors ? 2 : 0,
							flatShading: meshOutputGroup.smoothingGroup === 0
						}
					};
					var payload = {
						cmd: 'materialData',
						materials: {
							materialCloneInstructions: materialCloneInstructions
						}
					};
					this.callbackBuilder( payload );

					// fake entry for async; sync Parser always works on material references (Builder update directly visible here)
					if ( this.useAsync ) this.materials[ materialName ] = materialCloneInstructions;

				}

				if ( createMultiMaterial ) {

					// re-use material if already used before. Reduces materials array size and eliminates duplicates
					selectedMaterialIndex = materialIndexMapping[ materialName ];
					if ( ! selectedMaterialIndex ) {

						selectedMaterialIndex = materialIndex;
						materialIndexMapping[ materialName ] = materialIndex;
						materialNames.push( materialName );
						materialIndex++;

					}
					materialGroupLength = this.useIndices ? meshOutputGroup.indices.length : meshOutputGroup.vertices.length / 3;
					materialGroup = {
						start: materialGroupOffset,
						count: materialGroupLength,
						index: selectedMaterialIndex
					};
					materialGroups.push( materialGroup );
					materialGroupOffset += materialGroupLength;

				} else {

					materialNames.push( materialName );

				}

				vertexFA.set( meshOutputGroup.vertices, vertexFAOffset );
				vertexFAOffset += meshOutputGroup.vertices.length;

				if ( indexUA ) {

					indexUA.set( meshOutputGroup.indices, indexUAOffset );
					indexUAOffset += meshOutputGroup.indices.length;

				}

				if ( colorFA ) {

					colorFA.set( meshOutputGroup.colors, colorFAOffset );
					colorFAOffset += meshOutputGroup.colors.length;

				}

				if ( normalFA ) {

					normalFA.set( meshOutputGroup.normals, normalFAOffset );
					normalFAOffset += meshOutputGroup.normals.length;

				}
				if ( uvFA ) {

					uvFA.set( meshOutputGroup.uvs, uvFAOffset );
					uvFAOffset += meshOutputGroup.uvs.length;

				}

				if ( this.logger.isDebug() ) {
					var materialIndexLine = THREE.LoaderSupport.Validator.isValid( selectedMaterialIndex ) ? '\n\t\tmaterialIndex: ' + selectedMaterialIndex : '';
					var createdReport = '\tOutput Object no.: ' + this.outputObjectCount +
						'\n\t\tgroupName: ' + meshOutputGroup.groupName +
						'\n\t\tIndex: ' + meshOutputGroup.index +
						'\n\t\tfaceType: ' + this.rawMesh.faceType +
						'\n\t\tmaterialName: ' + meshOutputGroup.materialName +
						'\n\t\tsmoothingGroup: ' + meshOutputGroup.smoothingGroup +
						materialIndexLine +
						'\n\t\tobjectName: ' + meshOutputGroup.objectName +
						'\n\t\t#vertices: ' + meshOutputGroup.vertices.length / 3 +
						'\n\t\t#indices: ' + meshOutputGroup.indices.length +
						'\n\t\t#colors: ' + meshOutputGroup.colors.length / 3 +
						'\n\t\t#uvs: ' + meshOutputGroup.uvs.length / 2 +
						'\n\t\t#normals: ' + meshOutputGroup.normals.length / 3;
					this.logger.logDebug( createdReport );
				}

			}

			this.outputObjectCount++;
			this.callbackBuilder(
				{
					cmd: 'meshData',
					progress: {
						numericalValue: this.globalCounts.currentByte / this.globalCounts.totalBytes
					},
					params: {
						meshName: result.name
					},
					materials: {
						multiMaterial: createMultiMaterial,
						materialNames: materialNames,
						materialGroups: materialGroups
					},
					buffers: {
						vertices: vertexFA,
						indices: indexUA,
						colors: colorFA,
						normals: normalFA,
						uvs: uvFA
					},
					// 0: mesh, 1: line, 2: point
					geometryType: this.rawMesh.faceType < 4 ? 0 : ( this.rawMesh.faceType === 4 ) ? 1 : 2
				},
				[ vertexFA.buffer ],
				THREE.LoaderSupport.Validator.isValid( indexUA ) ? [ indexUA.buffer ] : null,
				THREE.LoaderSupport.Validator.isValid( colorFA ) ? [ colorFA.buffer ] : null,
				THREE.LoaderSupport.Validator.isValid( normalFA ) ? [ normalFA.buffer ] : null,
				THREE.LoaderSupport.Validator.isValid( uvFA ) ? [ uvFA.buffer ] : null
			);
		};

		Parser.prototype.finalizeParsing = function () {
			this.logger.logInfo( 'Global output object count: ' + this.outputObjectCount );
			if ( this.processCompletedMesh() && this.logger.isEnabled() ) {

				var parserFinalReport = 'Overall counts: ' +
					'\n\tVertices: ' + this.globalCounts.vertices +
					'\n\tFaces: ' + this.globalCounts.faces +
					'\n\tMultiple definitions: ' + this.globalCounts.doubleIndicesCount;
				this.logger.logInfo( parserFinalReport );

			}
		};

		return Parser;
	})();

	/**
	 * Utility method for loading an mtl file according resource description. Provide url or content.
	 * @memberOf THREE.OBJLoader2
	 *
	 * @param {string} url URL to the file
	 * @param {Object} content The file content as arraybuffer or text
	 * @param {function} callbackOnLoad Callback to be called after successful load
	 * @param {string} [crossOrigin] CORS value
 	 * @param {Object} [materialOptions] Set material loading options for MTLLoader
	 */
	OBJLoader2.prototype.loadMtl = function ( url, content, callbackOnLoad, crossOrigin, materialOptions ) {
		var resource = new THREE.LoaderSupport.ResourceDescriptor( url, 'MTL' );
		resource.setContent( content );
		this._loadMtl( resource, callbackOnLoad, crossOrigin, materialOptions );
	};

	OBJLoader2.prototype._loadMtl = function ( resource, callbackOnLoad, crossOrigin, materialOptions ) {
		if ( THREE.MTLLoader === undefined ) console.error( '"THREE.MTLLoader" is not available. "THREE.OBJLoader2" requires it for loading MTL files.' );
		if ( Validator.isValid( resource ) ) this.logger.logTimeStart( 'Loading MTL: ' + resource.name );

		var materials = [];
		var scope = this;
		var processMaterials = function ( materialCreator ) {
			var materialCreatorMaterials = [];
			if ( Validator.isValid( materialCreator ) ) {

				materialCreator.preload();
				materialCreatorMaterials = materialCreator.materials;
				for ( var materialName in materialCreatorMaterials ) {

					if ( materialCreatorMaterials.hasOwnProperty( materialName ) ) {

						materials[ materialName ] = materialCreatorMaterials[ materialName ];

					}
				}
			}

			if ( Validator.isValid( resource ) ) scope.logger.logTimeEnd( 'Loading MTL: ' + resource.name );
			callbackOnLoad( materials, materialCreator );
		};

		var mtlLoader = new THREE.MTLLoader( this.manager );
		crossOrigin = Validator.verifyInput( crossOrigin, 'anonymous' );
		mtlLoader.setCrossOrigin( crossOrigin );
		if ( Validator.isValid( materialOptions ) ) mtlLoader.setMaterialOptions( materialOptions );

		// fast-fail
		if ( ! Validator.isValid( resource ) || ( ! Validator.isValid( resource.content ) && ! Validator.isValid( resource.url ) ) ) {

			processMaterials();

		} else {

			mtlLoader.setPath( resource.path );
			if ( Validator.isValid( resource.content ) ) {

				processMaterials( Validator.isValid( resource.content ) ? mtlLoader.parse( resource.content ) : null );

			} else if ( Validator.isValid( resource.url ) ) {

				var onError = function ( event ) {
					var output = 'Error occurred while downloading "' + resource.url + '"';
					scope.logger.logError( output, event instanceof ProgressEvent ? [ 'Status: ' + event.currentTarget.statusText ] : null );
					throw output;
				};

				mtlLoader.load( resource.name, processMaterials, undefined, onError );

			}
		}
	};

	return OBJLoader2;
})();


text:
<?php

use yii\helpers\Html;
use yii\widgets\ActiveForm;
?>

	<?php $form = ActiveForm::begin([
		'action' => ['index'],
		'method' => 'get',
		'options' => [
			'data-pjax' => 1
		],
	]); ?>

		<?php echo $form->field($model, 'cityName');?>

		<?php echo $form->field($model, 'district_name');?>

		<?php echo $form->field($model, 'mfdonline');?>

		<?php echo $form->field($model, 'creation_date')
			->input('date');?>

		<?php echo $form->field($model, 'creationDisplayname');?>

		<?php echo $form->field($model, 'modified_date')
			->input('date');?>

		<?php echo $form->field($model, 'modifiedDisplayname');?>

		<?php echo $form->field($model, 'updated_date')
			->input('date');?>

		<?php echo $form->field($model, 'slug');?>

		<?php echo $form->field($model, 'checked')
			->dropDownList($model->filterYesNo(), ['prompt' => '']);?>

		<?php echo $form->field($model, 'publish')
			->dropDownList($model->filterYesNo(), ['prompt' => '']);?>

			<?php echo Html::submitButton(Yii::t('app', 'Search'), ['class' => 'btn btn-primary']); ?>
			<?php echo Html::resetButton(Yii::t('app', 'Reset'), ['class' => 'btn btn-default']); ?>

	<?php ActiveForm::end(); ?>


As I have already stated before any user can access the GSM system they must be authenticated as a valid user and this authentication is done by use of the PIN on the SIM. The SIM stores the users Individual Authentication Key Ki, the user identification IMSI and used the A3 algorithm for identification.
The authentication method that is used is challenge – response : the access control will generate a random number RAND as a challenge, and the SIM within the MS has to answer with a signed responses SRES as response. The AuC performs the basic generation of the RAND, signed responses SRES, and cipher key Kc for each IMSI, then forward this information to the HLR, then current VLR then requests the suitable values for the RAND, SRES and the Kc from the HLR.
For authentication the VLR sends the random value RAND to the SIM. Each side, the GSM network and the subscriber module, must perform the same operation with the RAND and the Ki. The MS sends back the SRES generated by the SIM, the VLR can now compare both values. If the value produced by the SIM and the VLR match then the user is granted to access the GSM network, however if they do not match then the subscriber is refused access to the network. This process is shown in Figure 16.


text:
Rare 1951 bottle of Grange sells for incredible $80k
Rare original bottle of 1951 vintage Penfolds Grange sells for record $80,386 at auction
A rare bottle of Grange from the original 1951 vintage has sold for a record $80,386 at an auction of Penfolds wines.
A full set of Grange from 1951 to 2013 has also fetched almost $350,000 in the Langton's online auction which closed on Sunday night.
The sale of the prized 1951 bottle eclipsed the previous record of $78,000 set earlier this year.
Langton's general manager Jeremy Parham said the latest auction presented a great opportunity for buyers of all tastes and budgets.
An original 1951 vintage bottle of Grange.
"This auction had something for everybody, from potential bargains to rare vintages to a selection of unique bottles like the pristine 1951 Penfolds Grange," he said.
The record price was around expectations.
The Grange vintage owes much of its status to its history, starting out as an experiment of Penfolds chief winemaker Max Schubert, who did not sell it commercially but gifted the wine to friends and family.
There are now fewer than 20 bottles of the vintage in the world.
Last year, a full set of Penfolds Grange sold for a record $260,360 to an Adelaide couple.
How this bottle could make you over $60k
New Aussie Costco has some jaw-dropping items
auction editors picks vintage wine


text:
Home Disney	5 Fun Facts about Pete's Dragon And New Trailer
DisneyentertainmentMovieNewQ&A
5 Fun Facts about Pete's Dragon And New Trailer
written by Sabina June 14, 2016
Check out the new trailer for Disney's Pete's Dragon and what director David Lowery alongside Bryce Dallas Howard had to say about being part of re-imagining a Disney Classic.
Last week we were able to attend a special preview of the trailer and check out some early footage from Pete's Dragon along with several members of the press. After the sneak peeks director David Lowery and his lead actress Bryce Dallas Howard chatted with us about the film.
Here are 5 things you need to know about the movie:
It's not a remake, in fact there isn't even any of the original music in the film. The footage gave us a glimpse of the world of the film which is nestled in a time before fancy tech where there was still wonder to behold. It's a whole new tale for a new generation, explained Lowery about his take on the Disney Classic:
David Lowery: The best thing is for audiences who love the original to see this and say, 'This is a great new film about a boy named Pete and a dragon named Elliott.' If kids have not seen the original, this will be the first time they've seen it. There won't be that moment where all of the adults go, 'Oh, yeah,' and the kids are like, 'I don't get it. What is it?' We avoided that. We talked about having references, but ultimately we felt like it was the purer tactic. I've seen a lot of remakes that do that, but it always takes me out of the movie to have that little wink.
Bryce Dallas Howard quickly signed on to the film being a fan of the original growing up. Even when she read this new version, she was taken by how much of a film about childhood it was.
Bryce Dallas Howard: I think that just as a parent the reason that I love children to watch films with children in them is because it empowers them to have an understanding. It contextualizes their own story, their own belief system and their own, their own emotional value. They learn to value their feelings.
In the preview and in the trailer we got a glimpse of Elliot the Dragon. He's may not look like the one we're familiar with but still emanates the love and care for Pete that we're familiar with. Lowery talked about his inspiration for the new look:
David Lowery: I love my cats. I was petting my cat and being like, 'I wish this guy was 20-feet tall.' He's really my cat. They have their own Instagram account. So, I wanted him to be furry. If you put a Game of Thrones dragon in this and had him be scaly and cold, it would be cool, but I wanted it to be the kind of dragon that you really wanted to give a hug to and snuggle up with.
Oakes Fegley is Pete and Oona Laurence is Natalie in Disney's PETE'S DRAGON, the story of a boy named Pete and his best friend Elliot, who just happens to be a dragon.
Bryce Dallas Howard praised the young actor who plays Pete. Compared him to her father the once child actor and now director Ron Howard.
Bryce Dallas Howard: There were often times when I would ask Oakes for direction. I would ask 'What do you think?'. He'd really know what to say. He reminded me of my dad in a lot of ways cause it's just sort of this talent. He's a self aware person but he's not aware of the extent of his talent and he's just really relaxed about it and has a sense of everything. He really understands a movie set. That's another thing to get a kid who's not self conscious who has that talent who's game, has the sturdiness, a deep sensitivity and is intuitive is beautiful to act opposite. If he chooses to he'll be a director.
While the film is a departure from the original, it's deeply rooted in the same vein as classic films about children. To Lowery, it was important to be true to childhood and his memories of being a kid:
David Lowery: This is a big adventure film. I want it to be respectful of children and their feelings. To be accurate to my memory to what it was like (to be a child). And also accurate to my memory of what I would do. I would build these tree forts in my backyard with rope swings. In my memory they're gigantic and awesome. I wanted to present that version through Pete. The version I saw in my mind's eye. But also when the characters are feeling things I wanted it to be true to my memory. I remember being a kid really clearly. I want to be true to that. There's a great legacy of films about children. Whether they are films like E.T. or Never Ending Story or the Black Stallion or other (foreign) films like The Red Balloon. They do a really good job of that. I think It's important to think of those movie because kids respond. Same with Miyasaki stuff. I like when kids see the emotional side of themselves.
Pete's Dragon opens August 12th!
5 Fun Facts about Pete's Dragon And New Trailer was last modified: June 14th, 2016 by Sabina
bryce dallas howarddavid loweryDisneyFamily filmoakes fegleypete's dragonPete's Dragon Trailerrated pgWalt Disney Studios
Pop culture and lifestyle writer. Lover of film and adventures with friends and family.
Summer Learning Resources from PBS KIDS
Pixar Director Alan Barillaro Introduces Piper
Pokemon Detective Pikachu Trailer Pairs Justice Smith And Ryan Reynolds As Pikachu To Solve A Mystery
5 Ideas and Gifts On Creating The Perfect Day For Your Superhero Dad! #SeeSteelFirst #ad
McFarland USA Is Perfect for the Entire Family #McFarlandUSA
Recipes! Hotel Transylvania 3: Summer Vacation Cocktails
Aasif Mandvi Discusses Million Dollar Arm #MillionDollarArmEvent
Disney 101 Dalmatians Diamond Edition Available February 10 #101Dalmatians
Mondo Poster for Jim Henson's Labyrinth
'Soul' Trailer Explores The Human Purpose In Heartfelt Ways
Stargirl: First Look and Interview with Grace VanderWaal
'FREAKY' Watch the Extended Look


text:
Another Unknown Tool For the Magnetic Messaging Download
Unix Unix is an operating program which was created in the Bell Labs in 1960s. This data may possibly consist of a image,an audio or video file,a library or an application. In this case no other separate card will be essential. Firewall Hardware or software devices that have been produced in such a way as to let, quit or proxy data by way of a network in which the level of trust is distinct for each is known as a firewall. Edutainment makes use of familiar types like television programs, computer and video games, films and music to instruct and socialize. Template Templates are formats which have currently been designed. It facilitates energy management. As described earlier, being a scripting language,JavaScript cannot be used to develop stand-alone applications,so it is as an alternative employed to develop net pages that are dynamic and interactive. Optical Media Discs that are read by a laser are named Optical media. E-mails,forums,search engines and on-line shopping malls fall below this category. Producing calls this way is much less costly as the user only pays for Internet access.
The address of a subscriber is automatically added to the list when the individual subscribes to it. Optical discs have a longer shelf life and are more affordable to create. AT is one of the frequently utilized power supplies. Rather, they are devices that are used to join several wired or wireless personal computer networks. The vibrations are translated to electrical signals. This language is used for adding,removing and modifying data in the database. Visual Display Unit: Popularly identified as a monitor, it is an electrical device that displays images developed as a outcome of the video outputs of computer systems. Linux Linux is a Unix-based operating system which was created by Linus Torvalds, as he was not satisfied with the at the moment available alternatives in Unix. It modulates analog carrier signals to encode digital information and demodulates it to decode the info transmitted. A process like sending an E-mail or logging into a web site entails a gateway which aids the connection take place.
Headphones, speakers, microphones and webcams are popularly utilised for operating multimedia applications on a pc. The hyperlink stands out when the cursor is moved over it, normally altering the arrow into a tiny hand pointing to the link. There are three varieties of keys on a laptop keyboard-Alphanumeric, which comprises letters and numbers. Sound Card: It is a pc expansion card that enables the input and output of audio signals to and from a laptop. This accomplished,the mouse button can be released. Gnutella is a Peer to peer network (P2P). Listserv A little program which automatically sends messages to numerous e-mail addresses which are present on a mailing list make up the listserv or list server. Host refers to a personal computer that acts as a server for other computer systems which are on a network. Download This term refers to getting or copying data from a primary supply to one more device.
The keyboard is employed to enter data into a computer. Functions such as opening files,interacting with an application or help are housed in the menu bar. Difficult Disk: It is a non-volatile storage device that retailers digital information on magnetic surfaces. Input/Output (I/O) As the name suggests this term is employed to refer to how diverse components of the Information Processing Technique communicate with each and every other. File sizes, tough disk space and personal computer memory are measured in bytes. Strong-state Drive: This storage device uses solid-state memory to store persistent information. House Web page It is a nearby file that loads when a net browser is began. Mainframe computers are mostly employed in huge businesses and for scientific purposes. Typically, mikes consist of a membrane that vibrates in response to sound. magnetic messaging download. Difficult Disk A spindle of magnetic disks, referred to as platters,that record and store details are named tough disks.
It is a function that protects computer systems which are connected to the World wide web from unauthorized viewing. Alert Box The little box that pops up to inform you that the pc you are working on is about to execute an operation which may have damaging consequences is named the alert box. Since Laptops had been designed for individuals who are on the move, they include a battery that enables them to operate without having getting connected to a terminal. Text Editor Text editor is a plan which can be used to input, update,delete,write or retailer information on the pc. Y Yobibyte Yobibyte is a unit of measurement which is equal to 2 to the 80th power. Flaming A term coined to refer to the act of posting or sending unpleasant messages over the Internet. Networks become far more efficient making use of the load balancing approach. Portal This term is utilised to refer to a internet site or a service that gives a broad spectrum of solutions and resources.
Tape drives have storage capacities ranging from a couple of megabytes to a number of gigabytes. Terms such as Kilobytes, megabytes,gigabytes and terabytes are utilised to measure bigger amounts of information. The tough disk shops information magnetically, simply because of which the recorded details recorded on it stays there even when the computer is turned off. With the advancement in pc technologies, we can look forward to the creation of several a lot more hardware components that translate technologies to action! Fundamentally the brain of the laptop,it is used to interpret laptop directions and assist in the processing of information. In this case, the voice information is sent making use of packets. It is employed to send information to other computer systems. A little charge is normally charged for the using this service. Data Details that has been processed and then stored in the laptop is known as data. It is utilised for tracking equipment, sending orders to warehouses,creating invoices and other E-commerce purposes. In this method, the things that are entered initial are also the very first ones to be removed.
The information can include text typed in a word processing document,words entered although searching using a search engine,or even info entered into an excel sheet. Every time data is saved or a system is installed on the computer, the info is written on the hard disk. This strategy is used although extracting information from a range of obtainable data. Following this the drum is rolled by way of a reservoir or toner,this is picked up by the charged portions of the drum. Laser Printer Laser Printers use a laser beam to produce an image on a drum. QuickTime Quicktime was created by Apple Inc. While functioning on a computer, a word, a file, a character or even a folder is removed when the delete essential is pressed on the keyboard. They serve as a useful tool as with the help of the mouse or the keyboard, icons can be minimized and maximized.
iframe http://www.youtube.com/embed/AyYu1rjy4nI?rel=0&controls=1 height="315" width="460"
This enable future e-mails to be sent to the new subscriber along with the other individuals on the list. Trojan Horse A trojan horse refers to a system that looks genuine,but performs some incorrect activity when it is run. Joystick: It is an input device that consists of a stick that is pivoted on a base and indicates its path to the device it controls. A modem can be either external or internal to the computer. Functions like adding,subtracting,multiplying and dividing are accomplished by the microprocessor. The amount of data sent more than a network is small and this information comes to the pc in the kind of several small packets. Software manufactures release periodic "security updates" to reduce hacking, especially in massive organization organizations. H Hardware The physical components of a pc and other associated devices are termed as personal computer hardware. Apart from the Start off button and the time,the job bar houses the programs which are open.
Here is a brief introduction to every of these storage media. It enhances the plug-and-play capabilities of a personal computer. The motion of a mouse translates into the motion of a pointer on the pc show, enabling the user to control a graphical user interface. Passwords guarantee that the laptop is not accessed with no permission. Tiny and easy factors like clicking or moving the mouse button to scanning a document is termed Input. Virus Viruses are tiny applications which are capable of causing harm to files and programs on the exact same network. Utilizing this software permits a laptop method to run a Java application,which is essential to view many World wide web pages. Let us look at some examples of these peripheral devices. Debug As the name suggests this term is utilized to get rid of bugs which stand for errors in programs. Firmware: It is a laptop program that is embedded in a hardware device.
Von "https://bildungsstreik.net/wiki/index.php/Another_Unknown_Tool_For_the_Magnetic_Messaging_Download"
Diese Seite wurde zuletzt am 9. August 2013 um 19:48 Uhr geändert.


text:
Snippets:6 December 2022
Published on: December 6, 2022
generic Quetiapine online Maharashtra receives buy prednisone National Award for Institutional Empowerment 2022 under category Badhamukta Vatavaran Ke Srijan Mein Sarvshrestha Rajya Award for making Buildings Accessible for Divyang Jan
Ministry of Culture organizes "Daakroom", the letter writing carnival in Association with Department of Post and Gandhi Smriti and Darshan Samiti is aimed to give a digital detox with the aim of reviving the art of letter writing in India.
Ministry of culture in collaboration with Ministry of Textile inaugurated Jharokha – Compendium of Indian handicraft, handloom, art and culture" at Dilli Haat, New Delhi.
World Soil Day (WSD) is held annually on 5 December as a means to focus attention on the importance of healthy soil and to advocate for the sustainable management of soil resources by FAO. World Soil Day 2022 Theme: "Soils: where food begins"
Rajeeva Laxman Karandikar named as chairperson of the National Statistical Commission
Canara Bank announced that it received the "Banker's Bank of the Year Award 2022" for the India segment at the Global Banking Summit, which was held in London, UK
Coastal Security Conference 2022 was held at Chennai
Saurashtra cricket team are the current champions of Vijay Hazare Trophy 2022 followed by Maharashtra as runner up
Ministry of Culture organizes International conference on the contributions of "J C Bose: A Satyagrahi Scientist" as part of Azadi Ka Amrit Mahotsava.
The 1st Sherpa Meeting of India's G20 Presidency begins in the historic city of Udaipur, Rajasthan


text:
Lynn Road was a football ground in the Newbury Park area of Ilford, London. It was the home ground of Ilford F.C. from 1904 until 1977 and hosted football matches during the 1948 Summer Olympics.

History
The ground was built in 1904 after Ilford were given notice to leave their Wellesley Road ground. The first match at the new ground was played against Clapton in September that year, and in November a new 400-seat stand was opened on the southern side of the pitch. They bought the freehold of the site in 1922, and built another stand (which became known as the Clock Stand) on the northern side of the pitch, seating 600. The original stand was demolished in 1928 and replaced by an 850-seat stand that included a paddock with a standing capacity of 950.

The record attendance of 17,000 was set for an English Schools Trophy match between Ilford and Swansea in May 1952. By this time the ground had a capacity of 18,000. Floodlights were subsequently installed in 1962.

In the 1970s plans were made to relocate to a new ground near Fairlop tube station and the club left in the summer of 1977, with the main stand dismantled in order to be moved to the new site. However, the new ground never materialised and Ilford subsequently merged with Leytonstone to form Leytonstone/Ilford.

Olympic matches

References

Ilford F.C.
Venues of the 1948 Summer Olympics
Olympic football venues
Defunct football venues in England
Football venues in London
Sport in the London Borough of Redbridge

redpajama_set_name: RedPajamaWikipedia