function particleslider(params) {
	var ps = this;

	ps.sliderid = 'particle-slider';


	ps.color = '#fff';


	ps.hovercolor = '#88f';


	ps.width = 0;


	ps.height = 0;


	ps.ptlgap = 0;


	ps.ptlsize = 1;


	ps.slidedelay = 10;


	ps.arrowpadding = 10;


	ps.showarrowcontrols = true;


	ps.onnextslide = null;


	ps.onwidthchange = null;


	ps.onheightchange = null;


	ps.onsizechange = null;


	ps.monochrome = false;


	ps.mouseforce = 10000;


	ps.restless = true;


	ps.imgs = [];
	
	
	ps.cirposition = null;   //gyk
	ps.cirnum = 5;   //gyk
	

	/*** value parsing ***/
	if (params) {
		var paramnames = [
			'color',
			'hovercolor',
			'width',
			'height',
			'ptlgap',
			'ptlsize',
			'slidedelay',
			'arrowpadding',
			'sliderid',
			'showarrowcontrols',
			'onnextslide',
			'monochrome',
			'mouseforce',
			'restless',
			'imgs',
			'onsizechange',
			'onwidthchange',
			'onheightchange'
		];
		for (var i = 0, ii = paramnames.length; i < ii; i++) {
			if (params[paramnames[i]]) ps[paramnames[i]] = params[paramnames[i]];
		}
	}

	/*** html references ***/
	ps.$container = ps.$('#' + ps.sliderid);
	ps.$$children = ps.$container.childnodes;
	ps.$controlscontainer = ps.$('.controls');
	ps.$$slides = ps.$('.slide', ps.$('.slides').childnodes, true);
	ps.$controlleft = null;
	ps.$controlright = null;
	ps.$canv = ps.$('.draw');

	ps.$srccanv = document.createelement('canvas');
	ps.$srccanv.style.display = 'none';
	ps.$container.appendchild(ps.$srccanv);
	ps.$prevcanv = document.createelement('canvas');
	ps.$prevcanv.style.display = 'none';
	ps.$container.appendchild(ps.$prevcanv);
	ps.$nextcanv = document.createelement('canvas');
	ps.$nextcanv.style.display = 'none';
	ps.$container.appendchild(ps.$nextcanv);
	ps.$overlay = document.createelement('p');
	ps.$container.appendchild(ps.$overlay);
	
	
	//gyk
	ps.$circanv=[];
	for(i=0;i<ps.cirnum;i++){
		ps.$circanv[i] = document.createelement('canvas');
		ps.$circanv[i].style.display = 'none';
		ps.$container.appendchild(ps.$circanv[i]);
	}
	ps.imgcir = null;
	
	var cirnamelis=$(".cir_namelis");  //banner_companyname
	for(i=0;i<cirnamelis.length;i++){
		var str=cirnamelis.eq(i).text();
		var arr=str.split("");
		var html="";
		for(j=0;j<arr.length;j++){
			var txt="<span><i class='in'>"+arr[j]+"</i><i class='out'>"+arr[j]+"</i></span>";
			html+=txt;
		}
		cirnamelis.eq(i).html(html);
	}
	
	ps.letterrotate = function(){
		for(i=0;i<cirnamelis.length;i++){
			(function(){
				var ii=i;
				var span=cirnamelis.eq(ii).find("span");
				for(j=0;j<span.length;j++){
					(function(){
						var k=j;
						settimeout(function(){
							cirnamelis.eq(ii).find("span").eq(k).find("i").toggleclass("in out");
						},k*80)
					})()
				}
			})()
		}
	}
	setinterval(function(){
		ps.letterrotate();
	},2000)
	//gyk
	






	ps.imgcontrolprev = null;
	ps.imgcontrolnext = null;

	if (ps.$$slides.length <= 1) ps.showarrowcontrols = false;
	if (ps.$controlscontainer && ps.$controlscontainer.childnodes && ps.showarrowcontrols == true) {
		ps.$controlleft = ps.$('.left', ps.$controlscontainer.childnodes);
		ps.$controlright = ps.$('.right', ps.$controlscontainer.childnodes);
		ps.imgcontrolprev = new image();
		ps.imgcontrolnext = new image();
		ps.imgcontrolprev.onload = function () {
			ps.$prevcanv.height = this.height;
			ps.$prevcanv.width = this.width;
			ps.loadingstep();
		};
		ps.imgcontrolnext.onload = function () {
			ps.$nextcanv.height = this.height;
			ps.$nextcanv.width = this.width;
			ps.loadingstep();
		};
		ps.imgcontrolprev.src = ps.$controlleft.getattribute('data-src');
		ps.imgcontrolnext.src = ps.$controlright.getattribute('data-src');
	} else {
		ps.showarrowcontrols = false;
	}
	
	//gyk
	if($('.cir_glis').length>0){
		ps.$cir = $('.cir_glis').get(0);
		ps.imgcir = new image();
		ps.imgcir.onload = function () {
			ps.$circanv[0].height = this.height;
			ps.$circanv[0].width = this.width;
			ps.loadingstep();
		};
		if(window.innerwidth >=768 ){
			ps.imgcir.src = ps.$cir.getattribute('data-src');
		}else{
			ps.imgcir.src = ps.$cir.getattribute('data-src-phone');
		}
		
	}
	
	
	
	
	if (ps.width <= 0) ps.width = ps.$container.clientwidth;
	if (ps.height <= 0) ps.height = ps.$container.clientheight;

	/*** private values (internal use) ***/
	ps.mousedownregion = 0;
	ps.colorarr = ps.parsecolor(ps.color);
	ps.hovercolorarr = ps.parsecolor(ps.hovercolor);
	ps.mx = -1;
	ps.my = -1;
	ps.swipeoffset = 0;
	ps.cw = ps.getcw();
	ps.ch = ps.getch();
	ps.frame = 0;
	ps.nextslidetimer = false;
	ps.currimg = 0;
	ps.lastimg = 0;
	ps.imagesloaded = 0;
	ps.pxlbuffer = { first: null };
	ps.recyclebuffer = { first: null };

	ps.ctx = ps.$canv.getcontext('2d');
	ps.srcctx = ps.$srccanv.getcontext('2d');
	ps.prevctx = ps.$prevcanv.getcontext('2d');
	ps.nextctx = ps.$nextcanv.getcontext('2d');
	
	//gyk
	ps.circtx=[];
	for(i=0;i<ps.cirnum;i++){
		ps.circtx[i]=ps.$circanv[i].getcontext('2d');
	}
	
	
	
	
	ps.$canv.width = ps.cw;
	ps.$canv.height = ps.ch;

	/*** extend array with shuffle function ***/
	ps.shuffle = function () {
		var tmp, rand;
		for (var i = 0, ii = this.length; i < ii; i++) {
			rand = math.floor(math.random() * ii);
			tmp = this[i];
			this[i] = this[rand];
			this[rand] = tmp;
		}
	}
	array.prototype.shuffle = ps.shuffle;

	/***** bind mose events *****/
	/*** canvas - mouseout ***/
	ps.$canv.onmouseout = function () {
		ps.mx = -1;
		ps.my = -1;
		ps.mousedownregion = 0;
	}

	/*** canvas - mousemove ***/
	ps.$canv.onmousemove = function (evt) {
		function getelementposition(param) {
			var x = 0, y = 0;
			var obj = (typeof param === 'string') ? ps.$(param) : param;
			if (obj) {
				x = obj.offsetleft;
				y = obj.offsettop;
				var body = document.getelementsbytagname('body')[0];
				while (obj.offsetparent && obj != body) {
					x += obj.offsetparent.offsetleft;
					y += obj.offsetparent.offsettop;
					obj = obj.offsetparent;
				}
			}
			this.x = x;
			this.y = y;
		}

		var divpos = new getelementposition(ps.$container);

		ps.mx = evt.clientx - divpos.x + document.body.scrollleft + document.documentelement.scrollleft;
		ps.my = evt.clienty - divpos.y + document.body.scrolltop + document.documentelement.scrolltop;
		
		
		//gyk
		if(ps.cirposition){
			var cirhover=[];
			var cirtruenum=0;
			for(i=0;i<ps.cirposition.length;i++){
				cirhover[i]=ps.mx >= ps.cirposition[i].x && ps.mx < (ps.cirposition[i].x + ps.$circanv[0].width) && ps.my >=ps.cirposition[i].y && ps.my < (ps.cirposition[i].y + ps.$circanv[0].height)
			}
			for(i=0;i<cirhover.length;i++){
				(function(){
					var j=i;
					if(cirhover[i]==true){
						cirtruenum++;
						//console.log(cirtruenum);
						//console.log(j);
						$(".cir_namelis").eq(j).addclass("active").siblings(".cir_namelis").removeclass("active");
					}
				})()
			}
			if( cirtruenum>0 ){
				$("#particle-slider").css({"cursor":"pointer"})
				$(".cir_name").addclass("visi");
			}else{
				$("#particle-slider").css({"cursor":"default"})
				$(".cir_name").removeclass("visi");
				$(".cir_namelis").removeclass("active");
			}
		}
		
		
		
		
	}

	
	
	



	/*** canvas - mousedown ***/
	ps.$canv.onmousedown = function () {
		if (ps.imgs.length > 1) {
			var region = 0;
			if (ps.mx >= 0 && ps.mx < ps.arrowpadding * 2 + ps.$prevcanv.width) {
				region = -1;
			} else if (ps.mx > 0 && ps.mx > ps.cw - (ps.arrowpadding * 2 + ps.$nextcanv.width)) {
				region = 1;
			}
			ps.mousedownregion = region;
		}
		
		
		
		//gyk
//		var cirhover=[];
//		for(i=0;i<ps.cirposition.length;i++){
//			cirhover[i]=ps.mx >= ps.cirposition[i].x && ps.mx < (ps.cirposition[i].x + ps.$circanv[0].width) && ps.my >=ps.cirposition[i].y && ps.my < (ps.cirposition[i].y + ps.$circanv[0].height)
//		}
//		for(i=0;i<cirhover.length;i++){
//			(function(){
//				var j=i;
//				if(cirhover[i]==true){
//					console.log(j);
//				}
//			})()
//		}
		
		
		
	}

	/*** canvas - mouseup ***/
	ps.$canv.onmouseup = function () {
		if (ps.imgs.length > 1) {
			var region = '';
			if (ps.mx >= 0 && ps.mx < ps.arrowpadding * 2 + ps.$prevcanv.width) {
				region = -1;
			} else if (ps.mx > 0 && ps.mx > ps.cw - (ps.arrowpadding * 2 + ps.$nextcanv.width)) {
				region = 1;
			}
			if (region != 0 && ps.mousedownregion != 0) {
				if (region != ps.mousedownregion) region *= -1;
				if (ps.nextslidetimer) cleartimeout(ps.nextslidetimer);
				ps.nextslide(region);

			}
			ps.mousedownregion = 0;
		}
	}

	/*** load images dynamicly ***/
	if (ps.imgs.length == 0) {
		for (var i = 0, ii = ps.$$slides.length; i < ii; i++) {
			var img = new image();
			ps.imgs.push(img);
			
			if(window.innerwidth >1280 ){
				img.src = ps.$$slides[i].getattribute('data-src');
			}else if( window.innerwidth >=768 ){
				img.src = ps.$$slides[i].getattribute('data-src-pad');
			}else{
				img.src = ps.$$slides[i].getattribute('data-src-phone');
			}
		}
	}
	if (ps.imgs.length > 0) {
		ps.imgs[0].onload = function () {
			ps.loadingstep();
		};
	}

	/*** render frames ***/
	window.requestanimationframe(function () { ps.nextframe(); });
}


var psparticle = function (ps) {
	this.ps = ps;

	this.ttl = null;

	this.color = ps.colorarr;

	this.next = null;
	this.prev = null;


	this.gravityx = 0;


	this.gravityy = 0;


	this.x = math.random() * ps.cw;


	this.y = math.random() * ps.ch;

	this.velocityx = math.random() * 10 - 5;


	this.velocityy = math.random() * 10 - 5;
}


psparticle.prototype.move = function () {
	var ps = this.ps;
	var p = this;
	if (this.ttl != null && this.ttl-- <= 0) {
		ps.swaplist(p, ps.pxlbuffer, ps.recyclebuffer);
		this.ttl = null;
		return;
	}
	var gravitydx = this.gravityx + ps.swipeoffset - this.x;
	var gravitydy = this.gravityy - this.y;
	var gravitydistance = math.sqrt(math.pow(gravitydx, 2) + math.pow(gravitydy, 2));
	var gravityangle = math.atan2(gravitydy, gravitydx);
	var gravityforce = gravitydistance * 0.01;
	if (ps.restless == true) {
		gravityforce += math.random() * 0.1 - 0.05;
	} else {
		if (gravityforce < 0.01) {
			this.x = this.gravityx + 0.25;
			this.y = this.gravityy + 0.25;
		}
	}

	var cursorforce = 0;
	var cursorangle = 0;

	if (ps.mx >= 0 && ps.mouseforce) {
		var cursordx = this.x - ps.mx;
		var cursordy = this.y - ps.my;
		cursorforce = math.min(ps.mouseforce / (math.pow(cursordx, 2) + math.pow(cursordy, 2)), ps.mouseforce);
		cursorangle = math.atan2(cursordy, cursordx);
		if (typeof this.color == 'function') {
			cursorangle += math.pi;
			cursorforce *= 0.001 + math.random() * 0.1 - 0.05;
		}
	}
	else {
		cursorforce = 0;
		cursorangle = 0;
	}

	this.velocityx += gravityforce * math.cos(gravityangle) + cursorforce * math.cos(cursorangle);
	this.velocityy += gravityforce * math.sin(gravityangle) + cursorforce * math.sin(cursorangle);

	this.velocityx *= 0.92;
	this.velocityy *= 0.92;

	this.x += this.velocityx;
	this.y += this.velocityy;

}

/* move particle to particleslider namespace */
particleslider.prototype.particle = psparticle;


particleslider.prototype.swaplist = function (p, srclist, dstlist) {
	var ps = this;

	if (p == null) {
		//p is not defined - create new particle
		p = new ps.particle(ps);
	} else {
		//remove p from srclist
		if (srclist.first == p) {
			if (p.next != null) {
				p.next.prev = null;
				srclist.first = p.next;
			}
			else {
				srclist.first = null;
			}
		}
		else {
			if (p.next == null) {
				p.prev.next = null;
			}
			else {
				p.prev.next = p.next;
				p.next.prev = p.prev;
			}
		}
	}

	//add to dstlist
	if (dstlist.first == null) {
		dstlist.first = p;
		p.prev = null;
		p.next = null;
	}
	else {
		p.next = dstlist.first;
		dstlist.first.prev = p;
		dstlist.first = p;
		p.prev = null;
	}
}


particleslider.prototype.parsecolor = function (result) {
	var tmp;
	var result = result.replace(' ', '');

	if (tmp = /^#([\da-fa-f]{2})([\da-fa-f]{2})([\da-fa-f]{2})/.exec(result)) {
		tmp = [parseint(tmp[1], 16), parseint(tmp[2], 16), parseint(tmp[3], 16)];
	} else if (tmp = /^#([\da-fa-f])([\da-fa-f])([\da-fa-f])/.exec(result)) {
		tmp = [parseint(tmp[1], 16) * 17, parseint(tmp[2], 16) * 17, parseint(tmp[3], 16) * 17];
	} else if (tmp = /^rgba\(([\d]+),([\d]+),([\d]+),([\d]+|[\d]*.[\d]+)\)/.exec(result)) {
		tmp = [+tmp[1], +tmp[2], +tmp[3], +tmp[4]];
	} else if (tmp = /^rgb\(([\d]+),([\d]+),([\d]+)\)/.exec(result)) {
		tmp = [+tmp[1], +tmp[2], +tmp[3]];
	} else return null;

	if (isnan(tmp[3])) {
		(tmp[3] = 1);
	}

	tmp[3] *= 255;

	return tmp;
}


particleslider.prototype.loadingstep = function () {
	var ps = this;
	ps.imagesloaded++;
	if (ps.imagesloaded >= 3 || ps.showarrowcontrols == false) {
		ps.resize();
		if (ps.slidedelay > 0) ps.nextslidetimer = settimeout(function () { ps.nextslide() }, 1000 * ps.slidedelay);
	}
}


particleslider.prototype.$ = function (query, elems, asarray) {
	var ps = this;
	if (query[0] == '.') {
		var elemclass = query.substr(1);
		if (!elems) elems = ps.$$children;
		var result = [];
		for (var i = 0, ii = elems.length; i < ii; i++) {
			if (elems[i].classname && elems[i].classname == elemclass) result.push(elems[i]);
		}
		if (result.length == 0) {
			return null;
		} else if (result.length == 1 && !asarray) {
			return result[0];
		} else {
			return result;
		}
	} else return document.getelementbyid(query.substr(1));
}


particleslider.prototype.nextframe = function () {
	var ps = this;

	if ((ps.mousedownregion == 1 && ps.mx < ps.cw / 2) || (ps.mousedownregion == -1 && ps.mx > ps.cw / 2)) {
		ps.swipeoffset = (ps.mx - ps.cw / 2);
	} else {
		ps.swipeoffset = 0;
	}

	var p = ps.pxlbuffer.first;
	var next = null;
	while (p != null) {
		next = p.next;
		p.move();
		p = next;
	}

	ps.drawparticles();

	if (ps.frame++ % 25 == 0 && (ps.cw != ps.getcw() || ps.ch != ps.getch())) {
		var tmpch = ps.getch();
		var tmpcw = ps.getcw();
		if (ps.ch != tmpcw) {
			if (typeof ps.onwidthchange === 'function') {
				ps.onwidthchange(ps, tmpcw);
			}
		}
		if (ps.ch != tmpch) {
			if (typeof ps.onheightchange === 'function') {
				ps.onheightchange(ps, tmpch);
			}
		}
		if (typeof ps.onsizechange === 'function') {
			ps.onsizechange(ps, tmpcw, tmpch);
		}
		ps.resize();
	}

	settimeout(function () {
		window.requestanimationframe(function () { ps.nextframe(); });
	}, 15);
}


particleslider.prototype.nextslide = function (count) {
	var ps = this;
	if (ps.nextslidetimer != null && ps.imgs.length > 1) {
		ps.currimg = (ps.currimg + ps.imgs.length + (count ? count : 1)) % ps.imgs.length;
		ps.resize();
		if (ps.slidedelay > 0) ps.nextslidetimer = settimeout(function () { ps.nextslide() }, 1000 * ps.slidedelay);
	}
	else {
		if (ps.slidedelay > 0) ps.nextslidetimer = settimeout(function () { ps.nextslide() }, 1000 * ps.slidedelay);
	}
	if (typeof ps.onnextslide === 'function') {
		ps.onnextslide(ps.currimg);
	}
}


particleslider.prototype.drawparticles = function () {
	var ps = this;

	//ps.ctx.fillstyle = 'rgba(0,0,0,1)';
	//ps.ctx.fillrect(0, 0, ps.cw, ps.ch);

	//for (var i = 0; i < ps.pxls.length; i++) {
	//	if (ps.pxls[i].x >= 0 && ps.pxls[i].x < ps.cw && ps.pxls[i].y >= 0 && ps.pxls[i].y < ps.ch) {
	//		ps.ctx.fillstyle = ((ps.pxls[i].left && ps.mx >= 0 && ps.mx < ps.arrowpadding * 2 + ps.arrowwidth) ||
	//				(ps.pxls[i].right && ps.mx > 0 && ps.mx > ps.cw - (ps.arrowpadding * 2 + ps.arrowwidth))) ? ps.hovercolor : ps.color;
	//		ps.ctx.beginpath();
	//		ps.ctx.arc(ps.pxls[i].x, ps.pxls[i].y, ps.ptlsize, 0, 2 * math.pi, false);
	//		ps.ctx.closepath();
	//		ps.ctx.fill();
	//	}
	//}

	//return;
	var imagedata = ps.ctx.createimagedata(ps.cw, ps.ch);
	var actualdata = imagedata.data;

	var index;
	var x;
	var y;
	var dx;
	var dy;
	var color;

	var p = ps.pxlbuffer.first;
	while (p != null) {
		x = ~~p.x;
		y = ~~p.y;

		for (dx = x; dx < x + ps.ptlsize && dx >= 0 && dx < ps.cw; dx++) {
			for (dy = y; dy < y + ps.ptlsize && dy >= 0 && dy < ps.ch; dy++) {
				index = (dy * imagedata.width + dx) * 4;
				color = typeof p.color == 'function' ? p.color() : p.color;
				actualdata[index + 0] = color[0];
				actualdata[index + 1] = color[1];
				actualdata[index + 2] = color[2];
				actualdata[index + 3] = color[3];
			}
		}

		p = p.next;
	}

	imagedata.data = actualdata;
	ps.ctx.putimagedata(imagedata, 0, 0);
}

particleslider.prototype.getpixelfromimagedata = function (imagedata, offsetx, offsety) {
	var ps = this;

	var result = [];
	for (var x = 0; x < imagedata.width; x += ps.ptlgap + 1) {
		for (var y = 0; y < imagedata.height; y += ps.ptlgap + 1) {
			i = (y * imagedata.width + x) * 4;

			if (imagedata.data[i + 3] > 0) {
				result.push({
					x: offsetx + x,
					y: offsety + y,
					color: (ps.monochrome == true ?
						[ps.colorarr[0], ps.colorarr[1], ps.colorarr[2], ps.colorarr[3]] :
						[imagedata.data[i], imagedata.data[i + 1], imagedata.data[i + 2], imagedata.data[i + 3]])
				});
			}
		}
	}
	return result;
}


particleslider.prototype.init = function (shuffe) {
	var ps = this;
	if (ps.imgs.length > 0) {
		ps.$srccanv.width = ps.imgs[ps.currimg].width;
		ps.$srccanv.height = ps.imgs[ps.currimg].height;
		
		ps.srcctx.clearrect(0, 0, ps.$srccanv.width, ps.$srccanv.height);
		ps.srcctx.drawimage(ps.imgs[ps.currimg], 0, 0);
		var tmpparticles = ps.getpixelfromimagedata(
			ps.srcctx.getimagedata(0, 0, ps.$srccanv.width, ps.$srccanv.height),
			~~((ps.cw / 2) - (ps.$srccanv.width / 2)),
			~~((ps.ch / 2) - (ps.$srccanv.height / 2))
		);
		
		if (ps.showarrowcontrols == true) {
			ps.prevctx.clearrect(0, 0, ps.$prevcanv.width, ps.$prevcanv.height);
			ps.prevctx.drawimage(ps.imgcontrolprev, 0, 0);
			var prevparticles = ps.getpixelfromimagedata(
				ps.prevctx.getimagedata(0, 0, ps.$prevcanv.width, ps.$prevcanv.height),
				ps.arrowpadding,
				~~(ps.ch / 2 - ps.$prevcanv.height / 2)
			);

			for (var i = 0, ii = prevparticles.length; i < ii; i++) {
				prevparticles[i].color = function () {
					return ps.mx >= 0 && ps.mx < ps.arrowpadding * 2 + ps.$prevcanv.width ? ps.hovercolorarr : ps.colorarr;
				};
				tmpparticles.push(prevparticles[i]);
			}

			ps.nextctx.clearrect(0, 0, ps.$nextcanv.width, ps.$nextcanv.height);
			ps.nextctx.drawimage(ps.imgcontrolnext, 0, 0);
			var nextparticles = ps.getpixelfromimagedata(
				ps.nextctx.getimagedata(0, 0, ps.$nextcanv.width, ps.$nextcanv.height),
				ps.cw - ps.arrowpadding - ps.$nextcanv.width,
				~~(ps.ch / 2 - ps.$nextcanv.height / 2)
			);
			for (var i = 0, ii = nextparticles.length; i < ii; i++) {
				nextparticles[i].color = function () {
					return ps.mx > 0 && ps.mx > ps.cw - (ps.arrowpadding * 2 + ps.$nextcanv.width) ? ps.hovercolorarr : ps.colorarr;
				};
				tmpparticles.push(nextparticles[i]);
			}
			
			
		}
		
		
			
		//gyk
		ps.cirposition=[{
			"x":~~((ps.cw / 2) - (ps.$srccanv.width / 2) +(ps.$srccanv.width*0.7315) ),
			"y":~~((ps.ch / 2) - (ps.$srccanv.height / 2) +(ps.$srccanv.height*0.1268) )
		},{
			"x":~~((ps.cw / 2) - (ps.$srccanv.width / 2) +(ps.$srccanv.width*0.4577) ),
			"y":~~((ps.ch / 2) - (ps.$srccanv.height / 2) +(ps.$srccanv.height*0.0203) )
		},{
			"x":~~((ps.cw / 2) - (ps.$srccanv.width / 2) +(ps.$srccanv.width*0.0247) ),
			"y":~~((ps.ch / 2) - (ps.$srccanv.height / 2) +(ps.$srccanv.height*0.4609) )
		},{
			"x":~~((ps.cw / 2) - (ps.$srccanv.width / 2) +(ps.$srccanv.width*0.3577) ),
			"y":~~((ps.ch / 2) - (ps.$srccanv.height / 2) +(ps.$srccanv.height*0.9442) )
		},{
			"x":~~((ps.cw / 2) - (ps.$srccanv.width / 2) +(ps.$srccanv.width*0.6649) ),
			"y":~~((ps.ch / 2) - (ps.$srccanv.height / 2) +(ps.$srccanv.height*0.8061) )
		}]
		
		var cirparticles=[];
		for(j=0;j<ps.cirnum;j++){
			ps.circtx[j].clearrect(0, 0, ps.$circanv[j].width, ps.$circanv[j].height);
			ps.circtx[j].drawimage(ps.imgcir, 0, 0);
			cirparticles[j] = ps.getpixelfromimagedata(
				ps.circtx[j].getimagedata(0, 0, ps.$circanv[j].width, ps.$circanv[j].height),
				ps.cirposition[j].x,
				ps.cirposition[j].y
			);
			for (var i = 0, ii = cirparticles[j].length; i < ii; i++) {
				cirparticles[j][i].color = function () {
					//console.log($co);
					return ps.parsecolor("#004793");
				};
				tmpparticles.push(cirparticles[j][i]);
			}
		}
		
		
			
			
			
		
		

		if (ps.currimg != ps.lastimg || shuffe == true) {
			tmpparticles.shuffle();
			ps.lastimg = ps.currimg;
		}

		var p = ps.pxlbuffer.first;
		for (var i = 0, ii = tmpparticles.length; i < ii; i++) {
			var target = null;
			if (p != null) {
				target = p;
				p = p.next;
			} else {
				ps.swaplist(ps.recyclebuffer.first, ps.recyclebuffer, ps.pxlbuffer);
				target = ps.pxlbuffer.first;
			}
			target.gravityx = tmpparticles[i].x;
			target.gravityy = tmpparticles[i].y;
			target.color = tmpparticles[i].color;
		}

		while (p != null) {
			p.ttl = ~~(math.random() * 10);
			p.gravityy = ~~(ps.ch * math.random());
			p.gravityx = ~~(ps.cw * math.random());
			p = p.next;
		}

		ps.$overlay.innerhtml = ps.$$slides[ps.currimg].innerhtml;
	}
}


particleslider.prototype.getcw = function () {
	var ps = this;
	return math.min(document.body.clientwidth, ps.width, ps.$container.clientwidth);
}


particleslider.prototype.getch = function () {
	var ps = this;
	return math.min(document.body.clientheight, ps.height, ps.$container.clientheight);
}


particleslider.prototype.resize = function () {
	var ps = this;
	ps.cw = ps.getcw();
	ps.ch = ps.getch();
	ps.$canv.width = ps.cw;
	ps.$canv.height = ps.ch;
	ps.init(true);
}


particleslider.prototype.setcolor = function (color) {
	var ps = this;
	ps.colorarr = ps.parsecolor(color);
}


particleslider.prototype.sethovercolor = function (color) {
	var ps = this;
	ps.hovercolorarr = ps.parsecolor(color);
}

particleslider.prototype.requestanimationframe = function (callback) {
	var ps = this;

	var fnanimframe = (
		window.requestanimationframe ||
		window.webkitrequestanimationframe ||
		window.mozrequestanimationframe ||
		window.orequestanimationframe ||
		window.msrequestanimationframe ||
		function (/* function */ callback) {
			window.settimeout(callback, 1000 / 60);
		}
	);
	fnanimframe(callback);
};