12 Nov

Meet sene iafeta internet marketing business training coach

Click here to see Sene performing the Haka at Nov 10 Cavanagh Success Academy Workshop at Pattaya Beach

Sene Iafeta is a big, tough, imposing, highly skilled and highly disciplined very friendly generous and helpful man from the land of the long white cloud (NewZealand) who currently lives with his wife and 5 children on the Gold Coast south of Brisbane, Queensland, Australia.

About 3 years ago Sene Iafeta retired from a long successful career in the hands-on police force to embrace with inspired enthusiasm and massive action the personal coaching of David Cavanagh in Internet Marketing and Business Training. As a consequence, he is already highly successful in his personal internet marketing businesses  as well as being a key player and personal coach for many as one of the “Three Amigos” in David Cavanagh’s Cavanagh Success Academy.

Come and meet Sene at the next Cavanagh Success Academy workshop at Pattaya 22nd July-2nd August 2011.(Hint!: Click this link NOW to see if there still a space for you and your partner!)

Sene Iafeta Testimonial given on Facebook to David Cavanagh 17th April 2011 

David, as a former Police officer and Fraud Investigator you know I don’t take any form of BS. I began with you 3 years ago as a complete internet newbie with no experience at all. Within 6 months you helped me build my own business and lea…rn everything I needed to know about how to make money on the internet. I am now an international internet coach, run my own successful internet marketing consulting business and have a great life with my wife, children and grand children. So thank you David, if people take ACTION and implement what you teach the result has to be success. Just be yourself my friend and have fun.

If you’re new here, you may want to subscribe to my RSS feed. Thanks for visiting!

12 Nov

Muebles omar (powered by cubecart)

Categoria  
Inicio Tienda
Archivos Importados Omar
Archivos y Armarios
Counters
Escritorios Ejecutivos
Escritorios Modulares
Informatica
Jazz
Joven Gris
Joven Palisander
Linea Haya Completa
Mesa de Reuniones
Muebles Variados
Platinum Cristal
Platinum Haya
Secretariales y Tecnicas
Set de Espera
Sillas Visitas
Sillones Alta Gerencia
Sillones Ejecutivos
Sofas
Taburetes
Productos Oferta
     

Producto Ofrecido
 

1011ag
 
 
 

Informacion
 
About Us
Contact Us
Terms & Conditions
Privacy Policy
Privacy Policy
About Us
Contact Us
Terms & Conditions
 
 
 
Saturday 15, September 2007
 
Inicio Tienda > Secretariales y Tecnicas

Mostrando: 1 – 16 Paginas: (2)  [1]  2  Ultima »

Imagen Titulo Descripcion Precio  
1011ag Silla tecnica con brazos fijos solo en color negro. $0.00
mas info
1011g Silla Secretarial sin brazo en color negro solo. neumatico. $0.00
mas info
Cafe Giratoria c/b en tacto piel Silla Giratoria Cafe, en madera de haya y tapizada en tacto piel de siete colores diferentes $0.00
mas info
Firenze c/b Disponible en tela azul, negro y vino $0.00
mas info
Firenze s/b n/a $0.00
mas info
Ibiza c /b n/a $0.00
mas info
Infiniti Gerencial c/b Tapizado en tacto piel de siete ( 7 ) colores diferentes $0.00
mas info
Infiniti s/b n/a $0.00
mas info
Secretarial Venecia s/b n/a $0.00
mas info
Silla Century Silla plastica giratoria, moderno dise�o, disponible en tres colores
azul, naranja y amarillo
$0.00
mas info
Silla Operario s/b n/a $0.00
mas info
Sillon 501 sin brazos Sillon 501 sin brazos, tapizado en tela azul , negra o vino $0.00
mas info
Sillon 502 con brazos Sillon 502 con brazos, tapizado en tela negra, azul o vino $0.00
mas info
Tecnico Venecia B/A n/a $0.00
mas info
Tecnico Venecia B/F n/a $0.00
mas info
Tom Tecnico c/b n/a $0.00
mas info

Paginas: (2)  [1]  2  Ultima »
 
 
 
Carro de Cotizacion
 

El carro esta vacio

 
 
 

Idioma
 
 
 
 

Lo M�s Popular
 
1. Linea Attia
2. Escritorio Ejecu..
3. Linea Creactive ..
4. Escritorio MS Pl..
5. Escritorio Joven..
6. Pc-119
7. Gerencial Genesi..
8. Counter Joven Gr..
9. Mesa Attia
10. Cafe S/B
 
 
 

Productos Oferta
 
Producto(s) en oferta!

 
 
 

12 Nov

Codkasomaaliyeed.com


Boost Your health with Video Instruction
Why buy 1 yogavideo when you can get a whole library of videos? With more health improving poses, boost your health with streaming yogavideos you can follow anywhere 24/7.
www.totalyogapractice.com

Gaiam Yoga DVDs & Videos
Huge selection of Gaiam Yoga DVDs & videos for all levels of practice.
www.Gaiam.com

YogaVideo – Slimtree.com
Free full-length exercise video. Exercise online in streaming video, featuring certified instructors. Start today in 3 easy steps. Become a member, sign in and select a video.
www.slimtree.com

YogaVideos and Props at Tools for Yoga
Practice and instructional YogaVideos, 20 min to 1 hr long. Featuring BKS Iyengar, Patricia Walden, and Rodney Yee. Prenatal-beginners-power-gentle-flexibility-breathing-kids-relaxation.
www.toolsforyoga.com

YogaVideos
Shape up with Yoga DVDs, accessories & more from QVC.
www.QVC.com

YogaVideo
Find a Great Yoga & Pilates DVD Buy the Exercise DVD Today.
www.exercisetv.tv

Kundalini YogaVideos
Buy direct from YogaTech. Kundalini Yoga DVDs, CDs, and books. Great range, big savings, speedy world-wide delivery.
www.yogatech.com

Happy Yoga
High quality 100% cotton mat, Non slip yoga mat.
www.happyyoga.net

YogaVideos at Amazon.com
Thousands of items at Amazon. Qualified orders over $25 ship free.
Amazon.com

YogaVideo
Online YogaVideo With Poses To Target Your Full Body.
www.fitnessmagazine.com

  

©2007 codkasomaaliyeed.com All rights reserved.

11 Nov

Christianplace :: view topic – ergo proxy (anime)

View previous topic :: View next topic   Author Message Hittokiri04

Joined: 21 Sep 2006
Posts: 151
Location: somwhere over the rainbow hijacking a leprechaun for gold

PostPosted: Wed Oct 11, 2006 1:26 am    Post subject: Ergo Proxy (anime) Reply with quote

Yeah I know many of you may not care but I just got it in the mail and I have to shout it to the world. Laughing
_________________
www.myspace.com/otakunocrazo

www.xanga.com/Super_Afro_Samurai_Guy
Hit me up sometime I don’t bite really…at least nt that hard Laughing

Back to top
View user's profileSend private messageAIM AddressMSN Messenger
SakerFalcon

Joined: 21 Sep 2006
Posts: 58
Location: On a mountain in the U.S. somewhere.

PostPosted: Sun Oct 15, 2006 2:59 am    Post subject: Reply with quote

I don’t know much about anime but I lfound it on wiki, and it looks cool…
_________________
A positive attitude may not solve all your problems, but it will annoy enough people to make it worth the effort.

-Herm Albright

Almost nobody dances sober, unless they happen to be insane.

-H.P. Lovecraft

Back to top
View user's profileSend private messageYahoo MessengerMSN Messenger
Hittokiri04

Joined: 21 Sep 2006
Posts: 151
Location: somwhere over the rainbow hijacking a leprechaun for gold

PostPosted: Mon Oct 16, 2006 12:34 pm    Post subject: Reply with quote

It is very good I am up to episode 18. It is very dark in tone ao if you do not like darker titles you may not like it. There isn’t really alot of bad content in it too which I like…well at least up to episode 18.
_________________
www.myspace.com/otakunocrazo

www.xanga.com/Super_Afro_Samurai_Guy
Hit me up sometime I don’t bite really…at least nt that hard Laughing

Back to top
View user's profileSend private messageAIM AddressMSN Messenger
The GP Fury
Site Admin

Joined: 01 May 2006
Posts: 251

PostPosted: Mon Oct 16, 2006 1:08 pm    Post subject: Reply with quote

You might want to change the title of the topic, something like “Ergo Proxy (anime)” since your current title looks like a spambot thread

Smile
_________________
FuryTech
Christian Blog Site
Who are you?

What do you want?

Where are you going?

Why are you here?

Do you have anything worth living for?

Back to top
View user's profileSend private messageSend e-mail
The GP Fury
Site Admin

Joined: 01 May 2006
Posts: 251

PostPosted: Mon Oct 16, 2006 8:25 pm    Post subject: Reply with quote

Oi….

Not a new topic….just rename this one….I’ll just do it

Smile
_________________
FuryTech
Christian Blog Site
Who are you?

What do you want?

Where are you going?

Why are you here?

Do you have anything worth living for?

Back to top
View user's profileSend private messageSend e-mail
Hittokiri04

Joined: 21 Sep 2006
Posts: 151
Location: somwhere over the rainbow hijacking a leprechaun for gold

PostPosted: Mon Oct 16, 2006 11:01 pm    Post subject: Reply with quote

Embarassed sorry about that.

But yeah does anyone have any opions on this anime?
_________________
www.myspace.com/otakunocrazo

www.xanga.com/Super_Afro_Samurai_Guy
Hit me up sometime I don’t bite really…at least nt that hard Laughing

Back to top
View user's profileSend private messageAIM AddressMSN Messenger
Display posts from previous:   
11 Nov

Christianplace :: view topic – my xanga

View previous topic :: View next topic   Author Message SkyMarshalOz

Joined: 13 May 2006
Posts: 17
Location: Oregon City, Oregon

PostPosted: Mon May 15, 2006 8:12 am    Post subject: My Xanga Reply with quote

Well, I already have it as my website, but I will put it here as well. I have a Xanga, that I update almost daily. I post on as many topics as I can, from Christianity and the church to politics to my personal thoughts and feelings. I just blog about whatever interests me at the time and hope for the best.
_________________
Beware of the man with two glass eyes for he is blind.
Back to top The GP Fury
Site Admin

Joined: 01 May 2006
Posts: 251

PostPosted: Mon May 15, 2006 9:35 am    Post subject: Reply with quote

So, where’s the link?

Smile
Back to top feathin

Joined: 10 May 2006
Posts: 53
Location: IL

PostPosted: Tue May 16, 2006 6:11 pm    Post subject: Reply with quote

His “www” icon below his post.

My xanga isn’t quite updated daily. Offically anyway. Sometimes it is updated several times a day. What is on there is random, usually just general blurbs about what is going on in my life, sometimes philosophical musings, sometimes theological musings, sometimes fun pictures.

www.xanga.com/feathin
_________________
*Child of Feanor*

Back to top The GP Fury
Site Admin

Joined: 01 May 2006
Posts: 251

PostPosted: Tue May 16, 2006 9:05 pm    Post subject: Reply with quote

Ooops, my mistake
Back to top The GP Fury
Site Admin

Joined: 01 May 2006
Posts: 251

Back to top Chicken_$oup
mmmmm… soup

11 Nov

Christianplace :: view topic – immigration

View previous topic :: View next topic  

Would you work?
Sure, I’d work in a field all day picking cotton  60%  [ 3 ]
Pick cotten?! Count me out! That sounds too familiar…  0%  [ 0 ]
No thanks. I’d rather mooch off my parents.  40%  [ 2 ]
Total Votes : 5


Author Message Chicken_$oup
mmmmm… soup

10 Nov

Designer inspired replica hermes necklaces rose golden color no fading with h logo long chain jewelry on sale

© Copyright 2010 chanelnecklaceonsale.com. All Rights Reserved.
Replica Chanel Necklaces,
Replica Chanel Hair Clip,
replica chanel earrings ,
Replica Cartier love ring,
Replica Pandora beads ,
Replica Juicy Couture bracelets ,
replica tiffany necklaces ,
replica Bvlgari rings ,
replica Cartier bangles ,
replica Dior bangles ,
replica Dolce&Gabbana; neclaces , replica Gucci cufflinks,
replica Hermes earrings,
replica Links bracelets,
replica Louis Vuitton bangles,Replica Vivienne Westwood earrings

Cheap designer inspired replica Hermes Necklaces rose golden color no fading with H logo long chain jewelry on sale

10 Nov

Sponsored Listings
Search Results Provided By FindWhat

   Search:     
High Performance Memory from OCZ Technology
Choose from PC2100 through PC4400 DDR memory. Performance memory manufacturer offers lifetime warranty and direct support. Find dual channel, ECC server memory and more!
www.ocztechnology.com
Kahlon Computer Memory and Batteries
Upgrade the memory on notebooks, desktops, servers, and printers. Batteries and AC adapters for brand name notebooks are also available.
www.kahlon.com
OEMPCWorld.com Computer Memory
Computer and laptop memory 40% off, online configurator, lifetime warranty, and money-back guarantee. Buy RAM, including DDR SDRAM, RDRAM Rambus and Flash.
www.oempcworld.com

10 Nov

Keurig ultra b70 – quiet brew technology

Keurig Ultra B70 – Quiet Brew Technology

Thursday, November 4th, 2010 at
4:49 am  

Espresso & Coffee Makers

  • keurig coffee.mov
  • Can I use ground espresso in a coffee maker?
  • La Pavoni Lusso espresso maker – the little big one!
  • How much coffee grounds should i use in an 15 oz coffee maker?
  • Can you make a cappuccino from a coffee maker?
  • DeLonghi BCO120T Coffee Maker, Espresso Combo
  • La Pavoni Europiccola : the best espresso maker
  • Casa Bella Luna Playa Del Coco Costa Rica
  • Which coffee makers make the best coffee?
  • A Brief History of Espresso
  • Mr. Coffee TF5 4-Cup Switch Coffeemaker, Black
  • DeLonghi ESAM6600 Gran Dama Digital Super-Automatic Espresso Machine
  • how do I use the steam spout on my expresso machine?
  • Cuisinart DCC-1100BK 12-Cup Programmable Coffeemaker, Black
  • Grinding Out The Answer On Which Coffee Maker

Blogroll

  • Bad credit home loans
  • bad credit mortgages
  • Currency Trading Strategy
  • Water Heaters
  • Categories

    • Black & Decker Coffeemaker
    • Braun Coffemaker
    • cappuccino coffee makers
    • cappuccino espresso maker
    • cappuccino maker
    • coffee maker
    • Cuisinart Thermal Coffeemaker
    • DeLonghi Espresso Maker
    • Hamilton Beach Coffeemaker
    • Mr. Coffee Espresso Machine
    • Nespresso Espresso Maker
  • Tags

    anyoneAutomaticbaristaBestblackbrewBunncappuccinoCarafecleancoffeecoffeemakercommercialCuisinartdelonghidrinksDripespressofrenchfromGoodGreathomekeuriglattemachinemachinesMakermakersmakingMuchneedperfectpressregularreviewSaecoshouldSinglestarbuckstassimoThermalusingWaterwithout
  • 09 Nov

    " + (title || document.title) + "

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “method”, type: Function},
    {name: “context”, mayBeNull: true}
    ]);
    if (e) throw e;
    return function() {
    var l = arguments.length;
    if (l > 0) {
    var args = [];
    for (var i = 0; i < l; i++) { args[i] = arguments[i]; } args[l] = context; return method.apply(this, args); } return method.call(this, context); } } Function.createDelegate = function Function$createDelegate(instance, method) { ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”, mayBeNull: true},
    {name: “method”, type: Function}
    ]);
    if (e) throw e;
    return function() {
    return method.apply(instance, arguments);
    }
    }
    Function.emptyFunction = Function.emptyMethod = function Function$emptyMethod() {
    ///

    }
    Function.validateParameters = function Function$validateParameters(parameters, expectedParameters, validateParameterCount) {
    ///

    /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “parameters”},
    {name: “expectedParameters”},
    {name: “validateParameterCount”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    return Function._validateParams(parameters, expectedParameters, validateParameterCount);
    }
    Function._validateParams = function Function$_validateParams(params, expectedParams, validateParameterCount) {
    var e, expectedLength = expectedParams.length;
    validateParameterCount = validateParameterCount || (typeof(validateParameterCount) === “undefined”);
    e = Function._validateParameterCount(params, expectedParams, validateParameterCount);
    if (e) {
    e.popStackFrame();
    return e;
    }
    for (var i = 0, l = params.length; i < l; i++) { var expectedParam = expectedParams[Math.min(i, expectedLength - 1)], paramName = expectedParam.name; if (expectedParam.parameterArray) { paramName += "[" + (i - expectedLength + 1) + "]"; } else if (!validateParameterCount && (i >= expectedLength)) {
    break;
    }
    e = Function._validateParameter(params[i], expectedParam, paramName);
    if (e) {
    e.popStackFrame();
    return e;
    }
    }
    return null;
    }
    Function._validateParameterCount = function Function$_validateParameterCount(params, expectedParams, validateParameterCount) {
    var i, error,
    expectedLen = expectedParams.length,
    actualLen = params.length;
    if (actualLen < expectedLen) { var minParams = expectedLen; for (i = 0; i < expectedLen; i++) { var param = expectedParams[i]; if (param.optional || param.parameterArray) { minParams--; } } if (actualLen < minParams) { error = true; } } else if (validateParameterCount && (actualLen > expectedLen)) {
    error = true;
    for (i = 0; i < expectedLen; i++) { if (expectedParams[i].parameterArray) { error = false; break; } } } if (error) { var e = Error.parameterCount(); e.popStackFrame(); return e; } return null; } Function._validateParameter = function Function$_validateParameter(param, expectedParam, paramName) { var e, expectedType = expectedParam.type, expectedInteger = !!expectedParam.integer, expectedDomElement = !!expectedParam.domElement, mayBeNull = !!expectedParam.mayBeNull; e = Function._validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName); if (e) { e.popStackFrame(); return e; } var expectedElementType = expectedParam.elementType, elementMayBeNull = !!expectedParam.elementMayBeNull; if (expectedType === Array && typeof(param) !== "undefined" && param !== null && (expectedElementType || !elementMayBeNull)) { var expectedElementInteger = !!expectedParam.elementInteger, expectedElementDomElement = !!expectedParam.elementDomElement; for (var i=0; i < param.length; i++) { var elem = param[i]; e = Function._validateParameterType(elem, expectedElementType, expectedElementInteger, expectedElementDomElement, elementMayBeNull, paramName + "[" + i + "]"); if (e) { e.popStackFrame(); return e; } } } return null; } Function._validateParameterType = function Function$_validateParameterType(param, expectedType, expectedInteger, expectedDomElement, mayBeNull, paramName) { var e, i; if (typeof(param) === "undefined") { if (mayBeNull) { return null; } else { e = Error.argumentUndefined(paramName); e.popStackFrame(); return e; } } if (param === null) { if (mayBeNull) { return null; } else { e = Error.argumentNull(paramName); e.popStackFrame(); return e; } } if (expectedType && expectedType.__enum) { if (typeof(param) !== 'number') { e = Error.argumentType(paramName, Object.getType(param), expectedType); e.popStackFrame(); return e; } if ((param % 1) === 0) { var values = expectedType.prototype; if (!expectedType.__flags || (param === 0)) { for (i in values) { if (values[i] === param) return null; } } else { var v = param; for (i in values) { var vali = values[i]; if (vali === 0) continue; if ((vali & param) === vali) { v -= vali; } if (v === 0) return null; } } } e = Error.argumentOutOfRange(paramName, param, String.format(Sys.Res.enumInvalidValue, param, expectedType.getName())); e.popStackFrame(); return e; } if (expectedDomElement && (!Sys._isDomElement(param) || (param.nodeType === 3))) { e = Error.argument(paramName, Sys.Res.argumentDomElement); e.popStackFrame(); return e; } if (expectedType && !Sys._isInstanceOfType(expectedType, param)) { e = Error.argumentType(paramName, Object.getType(param), expectedType); e.popStackFrame(); return e; } if (expectedType === Number && expectedInteger) { if ((param % 1) !== 0) { e = Error.argumentOutOfRange(paramName, param, Sys.Res.argumentInteger); e.popStackFrame(); return e; } } return null; } Error.__typeName = 'Error'; Error.__class = true; Error.create = function Error$create(message, errorInfo) { /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true, optional: true},
    {name: “errorInfo”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var err = new Error(message);
    err.message = message;
    if (errorInfo) {
    for (var v in errorInfo) {
    err[v] = errorInfo[v];
    }
    }
    err.popStackFrame();
    return err;
    }
    Error.argument = function Error$argument(paramName, message) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “paramName”, type: String, mayBeNull: true, optional: true},
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ArgumentException: ” + (message ? message : Sys.Res.argument);
    if (paramName) {
    displayMessage += “\n” + String.format(Sys.Res.paramName, paramName);
    }
    var err = Error.create(displayMessage, { name: “Sys.ArgumentException”, paramName: paramName });
    err.popStackFrame();
    return err;
    }
    Error.argumentNull = function Error$argumentNull(paramName, message) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “paramName”, type: String, mayBeNull: true, optional: true},
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ArgumentNullException: ” + (message ? message : Sys.Res.argumentNull);
    if (paramName) {
    displayMessage += “\n” + String.format(Sys.Res.paramName, paramName);
    }
    var err = Error.create(displayMessage, { name: “Sys.ArgumentNullException”, paramName: paramName });
    err.popStackFrame();
    return err;
    }
    Error.argumentOutOfRange = function Error$argumentOutOfRange(paramName, actualValue, message) {
    ///

    /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “paramName”, type: String, mayBeNull: true, optional: true},
    {name: “actualValue”, mayBeNull: true, optional: true},
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ArgumentOutOfRangeException: ” + (message ? message : Sys.Res.argumentOutOfRange);
    if (paramName) {
    displayMessage += “\n” + String.format(Sys.Res.paramName, paramName);
    }
    if (typeof(actualValue) !== “undefined” && actualValue !== null) {
    displayMessage += “\n” + String.format(Sys.Res.actualValue, actualValue);
    }
    var err = Error.create(displayMessage, {
    name: “Sys.ArgumentOutOfRangeException”,
    paramName: paramName,
    actualValue: actualValue
    });
    err.popStackFrame();
    return err;
    }
    Error.argumentType = function Error$argumentType(paramName, actualType, expectedType, message) {
    ///

    /// /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “paramName”, type: String, mayBeNull: true, optional: true},
    {name: “actualType”, type: Type, mayBeNull: true, optional: true},
    {name: “expectedType”, type: Type, mayBeNull: true, optional: true},
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ArgumentTypeException: “;
    if (message) {
    displayMessage += message;
    }
    else if (actualType && expectedType) {
    displayMessage +=
    String.format(Sys.Res.argumentTypeWithTypes, actualType.getName(), expectedType.getName());
    }
    else {
    displayMessage += Sys.Res.argumentType;
    }
    if (paramName) {
    displayMessage += “\n” + String.format(Sys.Res.paramName, paramName);
    }
    var err = Error.create(displayMessage, {
    name: “Sys.ArgumentTypeException”,
    paramName: paramName,
    actualType: actualType,
    expectedType: expectedType
    });
    err.popStackFrame();
    return err;
    }
    Error.argumentUndefined = function Error$argumentUndefined(paramName, message) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “paramName”, type: String, mayBeNull: true, optional: true},
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ArgumentUndefinedException: ” + (message ? message : Sys.Res.argumentUndefined);
    if (paramName) {
    displayMessage += “\n” + String.format(Sys.Res.paramName, paramName);
    }
    var err = Error.create(displayMessage, { name: “Sys.ArgumentUndefinedException”, paramName: paramName });
    err.popStackFrame();
    return err;
    }
    Error.format = function Error$format(message) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.FormatException: ” + (message ? message : Sys.Res.format);
    var err = Error.create(displayMessage, {name: ‘Sys.FormatException’});
    err.popStackFrame();
    return err;
    }
    Error.invalidOperation = function Error$invalidOperation(message) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.InvalidOperationException: ” + (message ? message : Sys.Res.invalidOperation);
    var err = Error.create(displayMessage, {name: ‘Sys.InvalidOperationException’});
    err.popStackFrame();
    return err;
    }
    Error.notImplemented = function Error$notImplemented(message) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.NotImplementedException: ” + (message ? message : Sys.Res.notImplemented);
    var err = Error.create(displayMessage, {name: ‘Sys.NotImplementedException’});
    err.popStackFrame();
    return err;
    }
    Error.parameterCount = function Error$parameterCount(message) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var displayMessage = “Sys.ParameterCountException: ” + (message ? message : Sys.Res.parameterCount);
    var err = Error.create(displayMessage, {name: ‘Sys.ParameterCountException’});
    err.popStackFrame();
    return err;
    }
    Error.prototype.popStackFrame = function Error$popStackFrame() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (typeof(this.stack) === “undefined” || this.stack === null ||
    typeof(this.fileName) === “undefined” || this.fileName === null ||
    typeof(this.lineNumber) === “undefined” || this.lineNumber === null) {
    return;
    }
    var stackFrames = this.stack.split(“\n”);
    var currentFrame = stackFrames[0];
    var pattern = this.fileName + “:” + this.lineNumber;
    while(typeof(currentFrame) !== “undefined” &&
    currentFrame !== null &&
    currentFrame.indexOf(pattern) === -1) {
    stackFrames.shift();
    currentFrame = stackFrames[0];
    }
    var nextFrame = stackFrames[1];
    if (typeof(nextFrame) === “undefined” || nextFrame === null) {
    return;
    }
    var nextFrameParts = nextFrame.match(/@(.*):(\d+)$/);
    if (typeof(nextFrameParts) === “undefined” || nextFrameParts === null) {
    return;
    }
    this.fileName = nextFrameParts[1];
    this.lineNumber = parseInt(nextFrameParts[2]);
    stackFrames.shift();
    this.stack = stackFrames.join(“\n”);
    }

    Object.__typeName = ‘Object’;
    Object.__class = true;
    Object.getType = function Object$getType(instance) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”}
    ]);
    if (e) throw e;
    var ctor = instance.constructor;
    if (!ctor || (typeof(ctor) !== “function”) || !ctor.__typeName || (ctor.__typeName === ‘Object’)) {
    return Object;
    }
    return ctor;
    }
    Object.getTypeName = function Object$getTypeName(instance) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”}
    ]);
    if (e) throw e;
    return Object.getType(instance).getName();
    }

    String.__typeName = ‘String’;
    String.__class = true;
    String.prototype.endsWith = function String$endsWith(suffix) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “suffix”, type: String}
    ]);
    if (e) throw e;
    return (this.substr(this.length – suffix.length) === suffix);
    }
    String.prototype.startsWith = function String$startsWith(prefix) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “prefix”, type: String}
    ]);
    if (e) throw e;
    return (this.substr(0, prefix.length) === prefix);
    }
    String.prototype.trim = function String$trim() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this.replace(/^\s+|\s+$/g, ”);
    }
    String.prototype.trimEnd = function String$trimEnd() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this.replace(/\s+$/, ”);
    }
    String.prototype.trimStart = function String$trimStart() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this.replace(/^\s+/, ”);
    }
    String.format = function String$format(format, args) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String},
    {name: “args”, mayBeNull: true, parameterArray: true}
    ]);
    if (e) throw e;
    return String._toFormattedString(false, arguments);
    }
    String._toFormattedString = function String$_toFormattedString(useLocale, args) {
    var result = ”;
    var format = args[0];
    for (var i=0;;) {
    var open = format.indexOf(‘{‘, i);
    var close = format.indexOf(‘}’, i);
    if ((open < 0) && (close < 0)) { result += format.slice(i); break; } if ((close > 0) && ((close < open) || (open < 0))) { if (format.charAt(close + 1) !== '}') { throw Error.argument('format', Sys.Res.stringFormatBraceMismatch); } result += format.slice(i, close + 1); i = close + 2; continue; } result += format.slice(i, open); i = open + 1; if (format.charAt(i) === '{') { result += '{'; i++; continue; } if (close < 0) throw Error.argument('format', Sys.Res.stringFormatBraceMismatch); var brace = format.substring(i, close); var colonIndex = brace.indexOf(':'); var argNumber = parseInt((colonIndex < 0)? brace : brace.substring(0, colonIndex), 10) + 1; if (isNaN(argNumber)) throw Error.argument('format', Sys.Res.stringFormatInvalid); var argFormat = (colonIndex < 0)? '' : brace.substring(colonIndex + 1); var arg = args[argNumber]; if (typeof(arg) === "undefined" || arg === null) { arg = ''; } if (arg.toFormattedString) { result += arg.toFormattedString(argFormat); } else if (useLocale && arg.localeFormat) { result += arg.localeFormat(argFormat); } else if (arg.format) { result += arg.format(argFormat); } else result += arg.toString(); i = close + 1; } return result; } Boolean.__typeName = 'Boolean'; Boolean.__class = true; Boolean.parse = function Boolean$parse(value) { /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String}
    ], false);
    if (e) throw e;
    var v = value.trim().toLowerCase();
    if (v === ‘false’) return false;
    if (v === ‘true’) return true;
    throw Error.argumentOutOfRange(‘value’, value, Sys.Res.boolTrueOrFalse);
    }

    Date.__typeName = ‘Date’;
    Date.__class = true;

    Number.__typeName = ‘Number’;
    Number.__class = true;

    RegExp.__typeName = ‘RegExp’;
    RegExp.__class = true;

    if (!window) this.window = this;
    window.Type = Function;
    Type.__fullyQualifiedIdentifierRegExp = new RegExp(“^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]([^ \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*[^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\])?$”, “i”);
    Type.__identifierRegExp = new RegExp(“^[^.0-9 \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\][^. \\s|,;:&*=+\\-()\\[\\]{}^%#@!~\\n\\r\\t\\f\\\\]*$”, “i”);
    Type.prototype.callBaseMethod = function Type$callBaseMethod(instance, name, baseArguments) {
    ///

    /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”},
    {name: “name”, type: String},
    {name: “baseArguments”, type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}
    ]);
    if (e) throw e;
    var baseMethod = Sys._getBaseMethod(this, instance, name);
    if (!baseMethod) throw Error.invalidOperation(String.format(Sys.Res.methodNotFound, name));
    if (!baseArguments) {
    return baseMethod.apply(instance);
    }
    else {
    return baseMethod.apply(instance, baseArguments);
    }
    }
    Type.prototype.getBaseMethod = function Type$getBaseMethod(instance, name) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”},
    {name: “name”, type: String}
    ]);
    if (e) throw e;
    return Sys._getBaseMethod(this, instance, name);
    }
    Type.prototype.getBaseType = function Type$getBaseType() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return (typeof(this.__baseType) === “undefined”) ? null : this.__baseType;
    }
    Type.prototype.getInterfaces = function Type$getInterfaces() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    var result = [];
    var type = this;
    while(type) {
    var interfaces = type.__interfaces;
    if (interfaces) {
    for (var i = 0, l = interfaces.length; i < l; i++) { var interfaceType = interfaces[i]; if (!Array.contains(result, interfaceType)) { result[result.length] = interfaceType; } } } type = type.__baseType; } return result; } Type.prototype.getName = function Type$getName() { /// ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return (typeof(this.__typeName) === “undefined”) ? “” : this.__typeName;
    }
    Type.prototype.implementsInterface = function Type$implementsInterface(interfaceType) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “interfaceType”, type: Type}
    ]);
    if (e) throw e;
    this.resolveInheritance();
    var interfaceName = interfaceType.getName();
    var cache = this.__interfaceCache;
    if (cache) {
    var cacheEntry = cache[interfaceName];
    if (typeof(cacheEntry) !== ‘undefined’) return cacheEntry;
    }
    else {
    cache = this.__interfaceCache = {};
    }
    var baseType = this;
    while (baseType) {
    var interfaces = baseType.__interfaces;
    if (interfaces) {
    if (Array.indexOf(interfaces, interfaceType) !== -1) {
    return cache[interfaceName] = true;
    }
    }
    baseType = baseType.__baseType;
    }
    return cache[interfaceName] = false;
    }
    Type.prototype.inheritsFrom = function Type$inheritsFrom(parentType) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “parentType”, type: Type}
    ]);
    if (e) throw e;
    this.resolveInheritance();
    var baseType = this.__baseType;
    while (baseType) {
    if (baseType === parentType) {
    return true;
    }
    baseType = baseType.__baseType;
    }
    return false;
    }
    Type.prototype.initializeBase = function Type$initializeBase(instance, baseArguments) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”},
    {name: “baseArguments”, type: Array, mayBeNull: true, optional: true, elementMayBeNull: true}
    ]);
    if (e) throw e;
    if (!Sys._isInstanceOfType(this, instance)) throw Error.argumentType(‘instance’, Object.getType(instance), this);
    this.resolveInheritance();
    if (this.__baseType) {
    if (!baseArguments) {
    this.__baseType.apply(instance);
    }
    else {
    this.__baseType.apply(instance, baseArguments);
    }
    }
    return instance;
    }
    Type.prototype.isImplementedBy = function Type$isImplementedBy(instance) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”, mayBeNull: true}
    ]);
    if (e) throw e;
    if (typeof(instance) === “undefined” || instance === null) return false;
    var instanceType = Object.getType(instance);
    return !!(instanceType.implementsInterface && instanceType.implementsInterface(this));
    }
    Type.prototype.isInstanceOfType = function Type$isInstanceOfType(instance) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “instance”, mayBeNull: true}
    ]);
    if (e) throw e;
    return Sys._isInstanceOfType(this, instance);
    }
    Type.prototype.registerClass = function Type$registerClass(typeName, baseType, interfaceTypes) {
    ///

    /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “typeName”, type: String},
    {name: “baseType”, type: Type, mayBeNull: true, optional: true},
    {name: “interfaceTypes”, type: Type, parameterArray: true}
    ]);
    if (e) throw e;
    if (!Type.__fullyQualifiedIdentifierRegExp.test(typeName)) throw Error.argument(‘typeName’, Sys.Res.notATypeName);
    var parsedName;
    try {
    parsedName = eval(typeName);
    }
    catch(e) {
    throw Error.argument(‘typeName’, Sys.Res.argumentTypeName);
    }
    if (parsedName !== this) throw Error.argument(‘typeName’, Sys.Res.badTypeName);
    if (Sys.__registeredTypes[typeName]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, typeName));
    if ((arguments.length > 1) && (typeof(baseType) === ‘undefined’)) throw Error.argumentUndefined(‘baseType’);
    if (baseType && !baseType.__class) throw Error.argument(‘baseType’, Sys.Res.baseNotAClass);
    this.prototype.constructor = this;
    this.__typeName = typeName;
    this.__class = true;
    if (baseType) {
    this.__baseType = baseType;
    this.__basePrototypePending = true;
    }
    Sys.__upperCaseTypes[typeName.toUpperCase()] = this;
    if (interfaceTypes) {
    this.__interfaces = [];
    this.resolveInheritance();
    for (var i = 2, l = arguments.length; i < l; i++) { var interfaceType = arguments[i]; if (!interfaceType.__interface) throw Error.argument('interfaceTypes[' + (i - 2) + ']', Sys.Res.notAnInterface); for (var methodName in interfaceType.prototype) { var method = interfaceType.prototype[methodName]; if (!this.prototype[methodName]) { this.prototype[methodName] = method; } } this.__interfaces.push(interfaceType); } } Sys.__registeredTypes[typeName] = true; return this; } Type.prototype.registerInterface = function Type$registerInterface(typeName) { /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “typeName”, type: String}
    ]);
    if (e) throw e;
    if (!Type.__fullyQualifiedIdentifierRegExp.test(typeName)) throw Error.argument(‘typeName’, Sys.Res.notATypeName);
    var parsedName;
    try {
    parsedName = eval(typeName);
    }
    catch(e) {
    throw Error.argument(‘typeName’, Sys.Res.argumentTypeName);
    }
    if (parsedName !== this) throw Error.argument(‘typeName’, Sys.Res.badTypeName);
    if (Sys.__registeredTypes[typeName]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, typeName));
    Sys.__upperCaseTypes[typeName.toUpperCase()] = this;
    this.prototype.constructor = this;
    this.__typeName = typeName;
    this.__interface = true;
    Sys.__registeredTypes[typeName] = true;
    return this;
    }
    Type.prototype.resolveInheritance = function Type$resolveInheritance() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (this.__basePrototypePending) {
    var baseType = this.__baseType;
    baseType.resolveInheritance();
    for (var memberName in baseType.prototype) {
    var memberValue = baseType.prototype[memberName];
    if (!this.prototype[memberName]) {
    this.prototype[memberName] = memberValue;
    }
    }
    delete this.__basePrototypePending;
    }
    }
    Type.getRootNamespaces = function Type$getRootNamespaces() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return Array.clone(Sys.__rootNamespaces);
    }
    Type.isClass = function Type$isClass(type) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “type”, mayBeNull: true}
    ]);
    if (e) throw e;
    if ((typeof(type) === ‘undefined’) || (type === null)) return false;
    return !!type.__class;
    }
    Type.isInterface = function Type$isInterface(type) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “type”, mayBeNull: true}
    ]);
    if (e) throw e;
    if ((typeof(type) === ‘undefined’) || (type === null)) return false;
    return !!type.__interface;
    }
    Type.isNamespace = function Type$isNamespace(object) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “object”, mayBeNull: true}
    ]);
    if (e) throw e;
    if ((typeof(object) === ‘undefined’) || (object === null)) return false;
    return !!object.__namespace;
    }
    Type.parse = function Type$parse(typeName, ns) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “typeName”, type: String, mayBeNull: true},
    {name: “ns”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var fn;
    if (ns) {
    fn = Sys.__upperCaseTypes[ns.getName().toUpperCase() + ‘.’ + typeName.toUpperCase()];
    return fn || null;
    }
    if (!typeName) return null;
    if (!Type.__htClasses) {
    Type.__htClasses = {};
    }
    fn = Type.__htClasses[typeName];
    if (!fn) {
    fn = eval(typeName);
    if (typeof(fn) !== ‘function’) throw Error.argument(‘typeName’, Sys.Res.notATypeName);
    Type.__htClasses[typeName] = fn;
    }
    return fn;
    }
    Type.registerNamespace = function Type$registerNamespace(namespacePath) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “namespacePath”, type: String}
    ]);
    if (e) throw e;
    Type._registerNamespace(namespacePath);
    }
    Type._registerNamespace = function Type$_registerNamespace(namespacePath) {
    if (!Type.__fullyQualifiedIdentifierRegExp.test(namespacePath)) throw Error.argument(‘namespacePath’, Sys.Res.invalidNameSpace);
    var rootObject = window;
    var namespaceParts = namespacePath.split(‘.’);
    for (var i = 0; i < namespaceParts.length; i++) { var currentPart = namespaceParts[i]; var ns = rootObject[currentPart]; var nsType = typeof(ns); if ((nsType !== "undefined") && (ns !== null)) { if (nsType === "function") { throw Error.invalidOperation(String.format(Sys.Res.namespaceContainsClass, namespaceParts.splice(0, i + 1).join('.'))); } if ((typeof(ns) !== "object") || (ns instanceof Array)) { throw Error.invalidOperation(String.format(Sys.Res.namespaceContainsNonObject, namespaceParts.splice(0, i + 1).join('.'))); } } if (!ns) { ns = rootObject[currentPart] = {}; } if (!ns.__namespace) { if ((i === 0) && (namespacePath !== "Sys")) { Sys.__rootNamespaces[Sys.__rootNamespaces.length] = ns; } ns.__namespace = true; ns.__typeName = namespaceParts.slice(0, i + 1).join('.'); var parsedName; try { parsedName = eval(ns.__typeName); } catch(e) { parsedName = null; } if (parsedName !== ns) { delete rootObject[currentPart]; throw Error.argument('namespacePath', Sys.Res.invalidNameSpace); } ns.getName = function ns$getName() {return this.__typeName;} } rootObject = ns; } } Type._checkDependency = function Type$_checkDependency(dependency, featureName) { var scripts = Type._registerScript._scripts, isDependent = (scripts ? (!!scripts[dependency]) : false); if ((typeof(featureName) !== 'undefined') && !isDependent) { throw Error.invalidOperation(String.format(Sys.Res.requiredScriptReferenceNotIncluded, featureName, dependency)); } return isDependent; } Type._registerScript = function Type$_registerScript(scriptName, dependencies) { var scripts = Type._registerScript._scripts; if (!scripts) { Type._registerScript._scripts = scripts = {}; } if (scripts[scriptName]) { throw Error.invalidOperation(String.format(Sys.Res.scriptAlreadyLoaded, scriptName)); } scripts[scriptName] = true; if (dependencies) { for (var i = 0, l = dependencies.length; i < l; i++) { var dependency = dependencies[i]; if (!Type._checkDependency(dependency)) { throw Error.invalidOperation(String.format(Sys.Res.scriptDependencyNotFound, scriptName, dependency)); } } } } Type._registerNamespace("Sys"); Sys.__upperCaseTypes = {}; Sys.__rootNamespaces = [Sys]; Sys.__registeredTypes = {}; Sys._isInstanceOfType = function Sys$_isInstanceOfType(type, instance) { if (typeof(instance) === "undefined" || instance === null) return false; if (instance instanceof type) return true; var instanceType = Object.getType(instance); return !!(instanceType === type) || (instanceType.inheritsFrom && instanceType.inheritsFrom(type)) || (instanceType.implementsInterface && instanceType.implementsInterface(type)); } Sys._getBaseMethod = function Sys$_getBaseMethod(type, instance, name) { if (!Sys._isInstanceOfType(type, instance)) throw Error.argumentType('instance', Object.getType(instance), type); var baseType = type.getBaseType(); if (baseType) { var baseMethod = baseType.prototype[name]; return (baseMethod instanceof Function) ? baseMethod : null; } return null; } Sys._isDomElement = function Sys$_isDomElement(obj) { var val = false; if (typeof (obj.nodeType) !== 'number') { var doc = obj.ownerDocument || obj.document || obj; if (doc != obj) { var w = doc.defaultView || doc.parentWindow; val = (w != obj); } else { val = (typeof (doc.body) === 'undefined'); } } return !val; } Array.__typeName = 'Array'; Array.__class = true; Array.add = Array.enqueue = function Array$enqueue(array, item) { /// /// /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    array[array.length] = item;
    }
    Array.addRange = function Array$addRange(array, items) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “items”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    array.push.apply(array, items);
    }
    Array.clear = function Array$clear(array) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    array.length = 0;
    }
    Array.clone = function Array$clone(array) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    if (array.length === 1) {
    return [array[0]];
    }
    else {
    return Array.apply(null, array);
    }
    }
    Array.contains = function Array$contains(array, item) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    return (Sys._indexOf(array, item) >= 0);
    }
    Array.dequeue = function Array$dequeue(array) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    return array.shift();
    }
    Array.forEach = function Array$forEach(array, method, instance) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “method”, type: Function},
    {name: “instance”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    for (var i = 0, l = array.length; i < l; i++) { var elt = array[i]; if (typeof(elt) !== 'undefined') method.call(instance, elt, i, array); } } Array.indexOf = function Array$indexOf(array, item, start) { /// /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true, optional: true},
    {name: “start”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    return Sys._indexOf(array, item, start);
    }
    Array.insert = function Array$insert(array, index, item) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “index”, mayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    array.splice(index, 0, item);
    }
    Array.parse = function Array$parse(value) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String, mayBeNull: true}
    ]);
    if (e) throw e;
    if (!value) return [];
    var v = eval(value);
    if (!Array.isInstanceOfType(v)) throw Error.argument(‘value’, Sys.Res.arrayParseBadFormat);
    return v;
    }
    Array.remove = function Array$remove(array, item) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    var index = Sys._indexOf(array, item);
    if (index >= 0) {
    array.splice(index, 1);
    }
    return (index >= 0);
    }
    Array.removeAt = function Array$removeAt(array, index) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “array”, type: Array, elementMayBeNull: true},
    {name: “index”, mayBeNull: true}
    ]);
    if (e) throw e;
    array.splice(index, 1);
    }
    Sys._indexOf = function Sys$_indexOf(array, item, start) {
    if (typeof(item) === “undefined”) return -1;
    var length = array.length;
    if (length !== 0) {
    start = start – 0;
    if (isNaN(start)) {
    start = 0;
    }
    else {
    if (isFinite(start)) {
    start = start – (start % 1);
    }
    if (start < 0) { start = Math.max(0, length + start); } } for (var i = start; i < length; i++) { if ((typeof(array[i]) !== "undefined") && (array[i] === item)) { return i; } } } return -1; } Type._registerScript._scripts = { "MicrosoftAjaxCore.js": true, "MicrosoftAjaxGlobalization.js": true, "MicrosoftAjaxSerialization.js": true, "MicrosoftAjaxComponentModel.js": true, "MicrosoftAjaxHistory.js": true, "MicrosoftAjaxNetwork.js" : true, "MicrosoftAjaxWebServices.js": true }; Sys.IDisposable = function Sys$IDisposable() { throw Error.notImplemented(); } function Sys$IDisposable$dispose() { throw Error.notImplemented(); } Sys.IDisposable.prototype = { dispose: Sys$IDisposable$dispose } Sys.IDisposable.registerInterface('Sys.IDisposable'); Sys.StringBuilder = function Sys$StringBuilder(initialText) { /// /// var e = Function._validateParams(arguments, [
    {name: “initialText”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    this._parts = (typeof(initialText) !== ‘undefined’ && initialText !== null && initialText !== ”) ?
    [initialText.toString()] : [];
    this._value = {};
    this._len = 0;
    }
    function Sys$StringBuilder$append(text) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “text”, mayBeNull: true}
    ]);
    if (e) throw e;
    this._parts[this._parts.length] = text;
    }
    function Sys$StringBuilder$appendLine(text) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “text”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    this._parts[this._parts.length] =
    ((typeof(text) === ‘undefined’) || (text === null) || (text === ”)) ?
    ‘\r\n’ : text + ‘\r\n’;
    }
    function Sys$StringBuilder$clear() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._parts = [];
    this._value = {};
    this._len = 0;
    }
    function Sys$StringBuilder$isEmpty() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._parts.length === 0) return true;
    return this.toString() === ”;
    }
    function Sys$StringBuilder$toString(separator) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “separator”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    separator = separator || ”;
    var parts = this._parts;
    if (this._len !== parts.length) {
    this._value = {};
    this._len = parts.length;
    }
    var val = this._value;
    if (typeof(val[separator]) === ‘undefined’) {
    if (separator !== ”) {
    for (var i = 0; i < parts.length;) { if ((typeof(parts[i]) === 'undefined') || (parts[i] === '') || (parts[i] === null)) { parts.splice(i, 1); } else { i++; } } } val[separator] = this._parts.join(separator); } return val[separator]; } Sys.StringBuilder.prototype = { append: Sys$StringBuilder$append, appendLine: Sys$StringBuilder$appendLine, clear: Sys$StringBuilder$clear, isEmpty: Sys$StringBuilder$isEmpty, toString: Sys$StringBuilder$toString } Sys.StringBuilder.registerClass('Sys.StringBuilder'); Sys.Browser = {}; Sys.Browser.InternetExplorer = {}; Sys.Browser.Firefox = {}; Sys.Browser.Safari = {}; Sys.Browser.Opera = {}; Sys.Browser.agent = null; Sys.Browser.hasDebuggerStatement = false; Sys.Browser.name = navigator.appName; Sys.Browser.version = parseFloat(navigator.appVersion); Sys.Browser.documentMode = 0; if (navigator.userAgent.indexOf(' MSIE ') > -1) {
    Sys.Browser.agent = Sys.Browser.InternetExplorer;
    Sys.Browser.version = parseFloat(navigator.userAgent.match(/MSIE (\d+\.\d+)/)[1]);
    if (Sys.Browser.version >= 8) {
    if (document.documentMode >= 7) {
    Sys.Browser.documentMode = document.documentMode;
    }
    }
    Sys.Browser.hasDebuggerStatement = true;
    }
    else if (navigator.userAgent.indexOf(‘ Firefox/’) > -1) {
    Sys.Browser.agent = Sys.Browser.Firefox;
    Sys.Browser.version = parseFloat(navigator.userAgent.match(/ Firefox\/(\d+\.\d+)/)[1]);
    Sys.Browser.name = ‘Firefox’;
    Sys.Browser.hasDebuggerStatement = true;
    }
    else if (navigator.userAgent.indexOf(‘ AppleWebKit/’) > -1) {
    Sys.Browser.agent = Sys.Browser.Safari;
    Sys.Browser.version = parseFloat(navigator.userAgent.match(/ AppleWebKit\/(\d+(\.\d+)?)/)[1]);
    Sys.Browser.name = ‘Safari’;
    }
    else if (navigator.userAgent.indexOf(‘Opera/’) > -1) {
    Sys.Browser.agent = Sys.Browser.Opera;
    }

    Sys.EventArgs = function Sys$EventArgs() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    }
    Sys.EventArgs.registerClass(‘Sys.EventArgs’);
    Sys.EventArgs.Empty = new Sys.EventArgs();

    Sys.CancelEventArgs = function Sys$CancelEventArgs() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    Sys.CancelEventArgs.initializeBase(this);
    this._cancel = false;
    }
    function Sys$CancelEventArgs$get_cancel() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._cancel;
    }
    function Sys$CancelEventArgs$set_cancel(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Boolean}]);
    if (e) throw e;
    this._cancel = value;
    }
    Sys.CancelEventArgs.prototype = {
    get_cancel: Sys$CancelEventArgs$get_cancel,
    set_cancel: Sys$CancelEventArgs$set_cancel
    }
    Sys.CancelEventArgs.registerClass(‘Sys.CancelEventArgs’, Sys.EventArgs);
    Type.registerNamespace(‘Sys.UI’);

    Sys._Debug = function Sys$_Debug() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    }
    function Sys$_Debug$_appendConsole(text) {
    if ((typeof(Debug) !== ‘undefined’) && Debug.writeln) {
    Debug.writeln(text);
    }
    if (window.console && window.console.log) {
    window.console.log(text);
    }
    if (window.opera) {
    window.opera.postError(text);
    }
    if (window.debugService) {
    window.debugService.trace(text);
    }
    }
    function Sys$_Debug$_appendTrace(text) {
    var traceElement = document.getElementById(‘TraceConsole’);
    if (traceElement && (traceElement.tagName.toUpperCase() === ‘TEXTAREA’)) {
    traceElement.value += text + ‘\n’;
    }
    }
    function Sys$_Debug$assert(condition, message, displayCaller) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “condition”, type: Boolean},
    {name: “message”, type: String, mayBeNull: true, optional: true},
    {name: “displayCaller”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    if (!condition) {
    message = (displayCaller && this.assert.caller) ?
    String.format(Sys.Res.assertFailedCaller, message, this.assert.caller) :
    String.format(Sys.Res.assertFailed, message);
    if (confirm(String.format(Sys.Res.breakIntoDebugger, message))) {
    this.fail(message);
    }
    }
    }
    function Sys$_Debug$clearTrace() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    var traceElement = document.getElementById(‘TraceConsole’);
    if (traceElement && (traceElement.tagName.toUpperCase() === ‘TEXTAREA’)) {
    traceElement.value = ”;
    }
    }
    function Sys$_Debug$fail(message) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “message”, type: String, mayBeNull: true}
    ]);
    if (e) throw e;
    this._appendConsole(message);
    if (Sys.Browser.hasDebuggerStatement) {
    eval(‘debugger’);
    }
    }
    function Sys$_Debug$trace(text) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “text”}
    ]);
    if (e) throw e;
    this._appendConsole(text);
    this._appendTrace(text);
    }
    function Sys$_Debug$traceDump(object, name) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “object”, mayBeNull: true},
    {name: “name”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var text = this._traceDump(object, name, true);
    }
    function Sys$_Debug$_traceDump(object, name, recursive, indentationPadding, loopArray) {
    name = name? name : ‘traceDump’;
    indentationPadding = indentationPadding? indentationPadding : ”;
    if (object === null) {
    this.trace(indentationPadding + name + ‘: null’);
    return;
    }
    switch(typeof(object)) {
    case ‘undefined’:
    this.trace(indentationPadding + name + ‘: Undefined’);
    break;
    case ‘number’: case ‘string’: case ‘boolean’:
    this.trace(indentationPadding + name + ‘: ‘ + object);
    break;
    default:
    if (Date.isInstanceOfType(object) || RegExp.isInstanceOfType(object)) {
    this.trace(indentationPadding + name + ‘: ‘ + object.toString());
    break;
    }
    if (!loopArray) {
    loopArray = [];
    }
    else if (Array.contains(loopArray, object)) {
    this.trace(indentationPadding + name + ‘: …’);
    return;
    }
    Array.add(loopArray, object);
    if ((object == window) || (object === document) ||
    (window.HTMLElement && (object instanceof HTMLElement)) ||
    (typeof(object.nodeName) === ‘string’)) {
    var tag = object.tagName? object.tagName : ‘DomElement’;
    if (object.id) {
    tag += ‘ – ‘ + object.id;
    }
    this.trace(indentationPadding + name + ‘ {‘ + tag + ‘}’);
    }
    else {
    var typeName = Object.getTypeName(object);
    this.trace(indentationPadding + name + (typeof(typeName) === ‘string’ ? ‘ {‘ + typeName + ‘}’ : ”));
    if ((indentationPadding === ”) || recursive) {
    indentationPadding += ” “;
    var i, length, properties, p, v;
    if (Array.isInstanceOfType(object)) {
    length = object.length;
    for (i = 0; i < length; i++) { this._traceDump(object[i], '[' + i + ']', recursive, indentationPadding, loopArray); } } else { for (p in object) { v = object[p]; if (!Function.isInstanceOfType(v)) { this._traceDump(v, p, recursive, indentationPadding, loopArray); } } } } } Array.remove(loopArray, object); } } Sys._Debug.prototype = { _appendConsole: Sys$_Debug$_appendConsole, _appendTrace: Sys$_Debug$_appendTrace, assert: Sys$_Debug$assert, clearTrace: Sys$_Debug$clearTrace, fail: Sys$_Debug$fail, trace: Sys$_Debug$trace, traceDump: Sys$_Debug$traceDump, _traceDump: Sys$_Debug$_traceDump } Sys._Debug.registerClass('Sys._Debug'); Sys.Debug = new Sys._Debug(); Sys.Debug.isDebug = true; function Sys$Enum$parse(value, ignoreCase) { /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String},
    {name: “ignoreCase”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    var values, parsed, val;
    if (ignoreCase) {
    values = this.__lowerCaseValues;
    if (!values) {
    this.__lowerCaseValues = values = {};
    var prototype = this.prototype;
    for (var name in prototype) {
    values[name.toLowerCase()] = prototype[name];
    }
    }
    }
    else {
    values = this.prototype;
    }
    if (!this.__flags) {
    val = (ignoreCase ? value.toLowerCase() : value);
    parsed = values[val.trim()];
    if (typeof(parsed) !== ‘number’) throw Error.argument(‘value’, String.format(Sys.Res.enumInvalidValue, value, this.__typeName));
    return parsed;
    }
    else {
    var parts = (ignoreCase ? value.toLowerCase() : value).split(‘,’);
    var v = 0;
    for (var i = parts.length – 1; i >= 0; i–) {
    var part = parts[i].trim();
    parsed = values[part];
    if (typeof(parsed) !== ‘number’) throw Error.argument(‘value’, String.format(Sys.Res.enumInvalidValue, value.split(‘,’)[i].trim(), this.__typeName));
    v |= parsed;
    }
    return v;
    }
    }
    function Sys$Enum$toString(value) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    if ((typeof(value) === ‘undefined’) || (value === null)) return this.__string;
    if ((typeof(value) != ‘number’) || ((value % 1) !== 0)) throw Error.argumentType(‘value’, Object.getType(value), this);
    var values = this.prototype;
    var i;
    if (!this.__flags || (value === 0)) {
    for (i in values) {
    if (values[i] === value) {
    return i;
    }
    }
    }
    else {
    var sorted = this.__sortedValues;
    if (!sorted) {
    sorted = [];
    for (i in values) {
    sorted[sorted.length] = {key: i, value: values[i]};
    }
    sorted.sort(function(a, b) {
    return a.value – b.value;
    });
    this.__sortedValues = sorted;
    }
    var parts = [];
    var v = value;
    for (i = sorted.length – 1; i >= 0; i–) {
    var kvp = sorted[i];
    var vali = kvp.value;
    if (vali === 0) continue;
    if ((vali & value) === vali) {
    parts[parts.length] = kvp.key;
    v -= vali;
    if (v === 0) break;
    }
    }
    if (parts.length && v === 0) return parts.reverse().join(‘, ‘);
    }
    throw Error.argumentOutOfRange(‘value’, value, String.format(Sys.Res.enumInvalidValue, value, this.__typeName));
    }
    Type.prototype.registerEnum = function Type$registerEnum(name, flags) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “name”, type: String},
    {name: “flags”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    if (!Type.__fullyQualifiedIdentifierRegExp.test(name)) throw Error.argument(‘name’, Sys.Res.notATypeName);
    var parsedName;
    try {
    parsedName = eval(name);
    }
    catch(e) {
    throw Error.argument(‘name’, Sys.Res.argumentTypeName);
    }
    if (parsedName !== this) throw Error.argument(‘name’, Sys.Res.badTypeName);
    if (Sys.__registeredTypes[name]) throw Error.invalidOperation(String.format(Sys.Res.typeRegisteredTwice, name));
    for (var j in this.prototype) {
    var val = this.prototype[j];
    if (!Type.__identifierRegExp.test(j)) throw Error.invalidOperation(String.format(Sys.Res.enumInvalidValueName, j));
    if (typeof(val) !== ‘number’ || (val % 1) !== 0) throw Error.invalidOperation(Sys.Res.enumValueNotInteger);
    if (typeof(this[j]) !== ‘undefined’) throw Error.invalidOperation(String.format(Sys.Res.enumReservedName, j));
    }
    Sys.__upperCaseTypes[name.toUpperCase()] = this;
    for (var i in this.prototype) {
    this[i] = this.prototype[i];
    }
    this.__typeName = name;
    this.parse = Sys$Enum$parse;
    this.__string = this.toString();
    this.toString = Sys$Enum$toString;
    this.__flags = flags;
    this.__enum = true;
    Sys.__registeredTypes[name] = true;
    }
    Type.isEnum = function Type$isEnum(type) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “type”, mayBeNull: true}
    ]);
    if (e) throw e;
    if ((typeof(type) === ‘undefined’) || (type === null)) return false;
    return !!type.__enum;
    }
    Type.isFlags = function Type$isFlags(type) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “type”, mayBeNull: true}
    ]);
    if (e) throw e;
    if ((typeof(type) === ‘undefined’) || (type === null)) return false;
    return !!type.__flags;
    }
    Sys.CollectionChange = function Sys$CollectionChange(action, newItems, newStartingIndex, oldItems, oldStartingIndex) {
    ///

    /// /// /// /// /// ///
    ///
    ///
    ///
    ///
    var e = Function._validateParams(arguments, [
    {name: “action”, type: Sys.NotifyCollectionChangedAction},
    {name: “newItems”, mayBeNull: true, optional: true},
    {name: “newStartingIndex”, type: Number, mayBeNull: true, integer: true, optional: true},
    {name: “oldItems”, mayBeNull: true, optional: true},
    {name: “oldStartingIndex”, type: Number, mayBeNull: true, integer: true, optional: true}
    ]);
    if (e) throw e;
    this.action = action;
    if (newItems) {
    if (!(newItems instanceof Array)) {
    newItems = [newItems];
    }
    }
    this.newItems = newItems || null;
    if (typeof newStartingIndex !== “number”) {
    newStartingIndex = -1;
    }
    this.newStartingIndex = newStartingIndex;
    if (oldItems) {
    if (!(oldItems instanceof Array)) {
    oldItems = [oldItems];
    }
    }
    this.oldItems = oldItems || null;
    if (typeof oldStartingIndex !== “number”) {
    oldStartingIndex = -1;
    }
    this.oldStartingIndex = oldStartingIndex;
    }
    Sys.CollectionChange.registerClass(“Sys.CollectionChange”);
    Sys.NotifyCollectionChangedAction = function Sys$NotifyCollectionChangedAction() {
    ///

    ///
    ///
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.NotifyCollectionChangedAction.prototype = {
    add: 0,
    remove: 1,
    reset: 2
    }
    Sys.NotifyCollectionChangedAction.registerEnum(‘Sys.NotifyCollectionChangedAction’);
    Sys.NotifyCollectionChangedEventArgs = function Sys$NotifyCollectionChangedEventArgs(changes) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “changes”, type: Array, elementType: Sys.CollectionChange}
    ]);
    if (e) throw e;
    this._changes = changes;
    Sys.NotifyCollectionChangedEventArgs.initializeBase(this);
    }
    function Sys$NotifyCollectionChangedEventArgs$get_changes() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._changes || [];
    }
    Sys.NotifyCollectionChangedEventArgs.prototype = {
    get_changes: Sys$NotifyCollectionChangedEventArgs$get_changes
    }
    Sys.NotifyCollectionChangedEventArgs.registerClass(“Sys.NotifyCollectionChangedEventArgs”, Sys.EventArgs);
    Sys.Observer = function Sys$Observer() {
    throw Error.invalidOperation();
    }
    Sys.Observer.registerClass(“Sys.Observer”);
    Sys.Observer.makeObservable = function Sys$Observer$makeObservable(target) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “target”}
    ]);
    if (e) throw e;
    var isArray = target instanceof Array,
    o = Sys.Observer;
    Sys.Observer._ensureObservable(target);
    if (target.setValue === o._observeMethods.setValue) return target;
    o._addMethods(target, o._observeMethods);
    if (isArray) {
    o._addMethods(target, o._arrayMethods);
    }
    return target;
    }
    Sys.Observer._ensureObservable = function Sys$Observer$_ensureObservable(target) {
    var type = typeof target;
    if ((type === “string”) || (type === “number”) || (type === “boolean”) || (type === “date”)) {
    throw Error.invalidOperation(String.format(Sys.Res.notObservable, type));
    }
    }
    Sys.Observer._addMethods = function Sys$Observer$_addMethods(target, methods) {
    for (var m in methods) {
    if (target[m] && (target[m] !== methods[m])) {
    throw Error.invalidOperation(String.format(Sys.Res.observableConflict, m));
    }
    target[m] = methods[m];
    }
    }
    Sys.Observer._addEventHandler = function Sys$Observer$_addEventHandler(target, eventName, handler) {
    Sys.Observer._getContext(target, true).events._addHandler(eventName, handler);
    }
    Sys.Observer.addEventHandler = function Sys$Observer$addEventHandler(target, eventName, handler) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “eventName”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._addEventHandler(target, eventName, handler);
    }
    Sys.Observer._removeEventHandler = function Sys$Observer$_removeEventHandler(target, eventName, handler) {
    Sys.Observer._getContext(target, true).events._removeHandler(eventName, handler);
    }
    Sys.Observer.removeEventHandler = function Sys$Observer$removeEventHandler(target, eventName, handler) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “eventName”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._removeEventHandler(target, eventName, handler);
    }
    Sys.Observer.raiseEvent = function Sys$Observer$raiseEvent(target, eventName, eventArgs) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “eventName”, type: String},
    {name: “eventArgs”, type: Sys.EventArgs}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    var ctx = Sys.Observer._getContext(target);
    if (!ctx) return;
    var handler = ctx.events.getHandler(eventName);
    if (handler) {
    handler(target, eventArgs);
    }
    }
    Sys.Observer.addPropertyChanged = function Sys$Observer$addPropertyChanged(target, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._addEventHandler(target, “propertyChanged”, handler);
    }
    Sys.Observer.removePropertyChanged = function Sys$Observer$removePropertyChanged(target, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._removeEventHandler(target, “propertyChanged”, handler);
    }
    Sys.Observer.beginUpdate = function Sys$Observer$beginUpdate(target) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “target”}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._getContext(target, true).updating = true;
    }
    Sys.Observer.endUpdate = function Sys$Observer$endUpdate(target) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “target”}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    var ctx = Sys.Observer._getContext(target);
    if (!ctx || !ctx.updating) return;
    ctx.updating = false;
    var dirty = ctx.dirty;
    ctx.dirty = false;
    if (dirty) {
    if (target instanceof Array) {
    var changes = ctx.changes;
    ctx.changes = null;
    Sys.Observer.raiseCollectionChanged(target, changes);
    }
    Sys.Observer.raisePropertyChanged(target, “”);
    }
    }
    Sys.Observer.isUpdating = function Sys$Observer$isUpdating(target) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “target”}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    var ctx = Sys.Observer._getContext(target);
    return ctx ? ctx.updating : false;
    }
    Sys.Observer._setValue = function Sys$Observer$_setValue(target, propertyName, value) {
    var getter, setter, mainTarget = target, path = propertyName.split(‘.’);
    for (var i = 0, l = (path.length – 1); i < l ; i++) { var name = path[i]; getter = target["get_" + name]; if (typeof (getter) === "function") { target = getter.call(target); } else { target = target[name]; } var type = typeof (target); if ((target === null) || (type === "undefined")) { throw Error.invalidOperation(String.format(Sys.Res.nullReferenceInPath, propertyName)); } } var currentValue, lastPath = path[l]; getter = target["get_" + lastPath]; setter = target["set_" + lastPath]; if (typeof(getter) === 'function') { currentValue = getter.call(target); } else { currentValue = target[lastPath]; } if (typeof(setter) === 'function') { setter.call(target, value); } else { target[lastPath] = value; } if (currentValue !== value) { var ctx = Sys.Observer._getContext(mainTarget); if (ctx && ctx.updating) { ctx.dirty = true; return; }; Sys.Observer.raisePropertyChanged(mainTarget, path[0]); } } Sys.Observer.setValue = function Sys$Observer$setValue(target, propertyName, value) { /// /// /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “propertyName”, type: String},
    {name: “value”, mayBeNull: true}
    ]);
    if (e) throw e;
    Sys.Observer._ensureObservable(target);
    Sys.Observer._setValue(target, propertyName, value);
    }
    Sys.Observer.raisePropertyChanged = function Sys$Observer$raisePropertyChanged(target, propertyName) {
    ///

    /// /// Sys.Observer.raiseEvent(target, “propertyChanged”, new Sys.PropertyChangedEventArgs(propertyName));
    }
    Sys.Observer.addCollectionChanged = function Sys$Observer$addCollectionChanged(target, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._addEventHandler(target, “collectionChanged”, handler);
    }
    Sys.Observer.removeCollectionChanged = function Sys$Observer$removeCollectionChanged(target, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._removeEventHandler(target, “collectionChanged”, handler);
    }
    Sys.Observer._collectionChange = function Sys$Observer$_collectionChange(target, change) {
    var ctx = Sys.Observer._getContext(target);
    if (ctx && ctx.updating) {
    ctx.dirty = true;
    var changes = ctx.changes;
    if (!changes) {
    ctx.changes = changes = [change];
    }
    else {
    changes.push(change);
    }
    }
    else {
    Sys.Observer.raiseCollectionChanged(target, [change]);
    Sys.Observer.raisePropertyChanged(target, ‘length’);
    }
    }
    Sys.Observer.add = function Sys$Observer$add(target, item) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], target.length);
    Array.add(target, item);
    Sys.Observer._collectionChange(target, change);
    }
    Sys.Observer.addRange = function Sys$Observer$addRange(target, items) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “items”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    var change = new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, items, target.length);
    Array.addRange(target, items);
    Sys.Observer._collectionChange(target, change);
    }
    Sys.Observer.clear = function Sys$Observer$clear(target) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true}
    ]);
    if (e) throw e;
    var oldItems = Array.clone(target);
    Array.clear(target);
    Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.reset, null, -1, oldItems, 0));
    }
    Sys.Observer.insert = function Sys$Observer$insert(target, index, item) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “index”, type: Number, integer: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    Array.insert(target, index, item);
    Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.add, [item], index));
    }
    Sys.Observer.remove = function Sys$Observer$remove(target, item) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “item”, mayBeNull: true}
    ]);
    if (e) throw e;
    var index = Array.indexOf(target, item);
    if (index !== -1) {
    Array.remove(target, item);
    Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index));
    return true;
    }
    return false;
    }
    Sys.Observer.removeAt = function Sys$Observer$removeAt(target, index) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”, type: Array, elementMayBeNull: true},
    {name: “index”, type: Number, integer: true}
    ]);
    if (e) throw e;
    if ((index > -1) && (index < target.length)) { var item = target[index]; Array.removeAt(target, index); Sys.Observer._collectionChange(target, new Sys.CollectionChange(Sys.NotifyCollectionChangedAction.remove, null, -1, [item], index)); } } Sys.Observer.raiseCollectionChanged = function Sys$Observer$raiseCollectionChanged(target, changes) { /// /// /// Sys.Observer.raiseEvent(target, “collectionChanged”, new Sys.NotifyCollectionChangedEventArgs(changes));
    }
    Sys.Observer._observeMethods = {
    add_propertyChanged: function(handler) {
    Sys.Observer._addEventHandler(this, “propertyChanged”, handler);
    },
    remove_propertyChanged: function(handler) {
    Sys.Observer._removeEventHandler(this, “propertyChanged”, handler);
    },
    addEventHandler: function(eventName, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “eventName”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._addEventHandler(this, eventName, handler);
    },
    removeEventHandler: function(eventName, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “eventName”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.Observer._removeEventHandler(this, eventName, handler);
    },
    get_isUpdating: function() {
    ///

    ///
    return Sys.Observer.isUpdating(this);
    },
    beginUpdate: function() {
    ///

    Sys.Observer.beginUpdate(this);
    },
    endUpdate: function() {
    ///

    Sys.Observer.endUpdate(this);
    },
    setValue: function(name, value) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “name”, type: String},
    {name: “value”, mayBeNull: true}
    ]);
    if (e) throw e;
    Sys.Observer._setValue(this, name, value);
    },
    raiseEvent: function(eventName, eventArgs) {
    ///

    /// /// Sys.Observer.raiseEvent(this, eventName, eventArgs);
    },
    raisePropertyChanged: function(name) {
    ///

    /// Sys.Observer.raiseEvent(this, “propertyChanged”, new Sys.PropertyChangedEventArgs(name));
    }
    }
    Sys.Observer._arrayMethods = {
    add_collectionChanged: function(handler) {
    Sys.Observer._addEventHandler(this, “collectionChanged”, handler);
    },
    remove_collectionChanged: function(handler) {
    Sys.Observer._removeEventHandler(this, “collectionChanged”, handler);
    },
    add: function(item) {
    ///

    /// Sys.Observer.add(this, item);
    },
    addRange: function(items) {
    ///

    /// Sys.Observer.addRange(this, items);
    },
    clear: function() {
    ///

    Sys.Observer.clear(this);
    },
    insert: function(index, item) {
    ///

    /// /// Sys.Observer.insert(this, index, item);
    },
    remove: function(item) {
    ///

    /// ///
    return Sys.Observer.remove(this, item);
    },
    removeAt: function(index) {
    ///

    /// Sys.Observer.removeAt(this, index);
    },
    raiseCollectionChanged: function(changes) {
    ///

    /// Sys.Observer.raiseEvent(this, “collectionChanged”, new Sys.NotifyCollectionChangedEventArgs(changes));
    }
    }
    Sys.Observer._getContext = function Sys$Observer$_getContext(obj, create) {
    var ctx = obj._observerContext;
    if (ctx) return ctx();
    if (create) {
    return (obj._observerContext = Sys.Observer._createContext())();
    }
    return null;
    }
    Sys.Observer._createContext = function Sys$Observer$_createContext() {
    var ctx = {
    events: new Sys.EventHandlerList()
    };
    return function() {
    return ctx;
    }
    }
    Date._appendPreOrPostMatch = function Date$_appendPreOrPostMatch(preMatch, strBuilder) {
    var quoteCount = 0;
    var escaped = false;
    for (var i = 0, il = preMatch.length; i < il; i++) { var c = preMatch.charAt(i); switch (c) { case '\'': if (escaped) strBuilder.append("'"); else quoteCount++; escaped = false; break; case '\\': if (escaped) strBuilder.append("\\"); escaped = !escaped; break; default: strBuilder.append(c); escaped = false; break; } } return quoteCount; } Date._expandFormat = function Date$_expandFormat(dtf, format) { if (!format) { format = "F"; } var len = format.length; if (len === 1) { switch (format) { case "d": return dtf.ShortDatePattern; case "D": return dtf.LongDatePattern; case "t": return dtf.ShortTimePattern; case "T": return dtf.LongTimePattern; case "f": return dtf.LongDatePattern + " " + dtf.ShortTimePattern; case "F": return dtf.FullDateTimePattern; case "M": case "m": return dtf.MonthDayPattern; case "s": return dtf.SortableDateTimePattern; case "Y": case "y": return dtf.YearMonthPattern; default: throw Error.format(Sys.Res.formatInvalidString); } } else if ((len === 2) && (format.charAt(0) === "%")) { format = format.charAt(1); } return format; } Date._expandYear = function Date$_expandYear(dtf, year) { var now = new Date(), era = Date._getEra(now); if (year < 100) { var curr = Date._getEraYear(now, dtf, era); year += curr - (curr % 100); if (year > dtf.Calendar.TwoDigitYearMax) {
    year -= 100;
    }
    }
    return year;
    }
    Date._getEra = function Date$_getEra(date, eras) {
    if (!eras) return 0;
    var start, ticks = date.getTime();
    for (var i = 0, l = eras.length; i < l; i += 4) { start = eras[i+2]; if ((start === null) || (ticks >= start)) {
    return i;
    }
    }
    return 0;
    }
    Date._getEraYear = function Date$_getEraYear(date, dtf, era, sortable) {
    var year = date.getFullYear();
    if (!sortable && dtf.eras) {
    year -= dtf.eras[era + 3];
    }
    return year;
    }
    Date._getParseRegExp = function Date$_getParseRegExp(dtf, format) {
    if (!dtf._parseRegExp) {
    dtf._parseRegExp = {};
    }
    else if (dtf._parseRegExp[format]) {
    return dtf._parseRegExp[format];
    }
    var expFormat = Date._expandFormat(dtf, format);
    expFormat = expFormat.replace(/([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, “\\\\”);
    var regexp = new Sys.StringBuilder(“^”);
    var groups = [];
    var index = 0;
    var quoteCount = 0;
    var tokenRegExp = Date._getTokenRegExp();
    var match;
    while ((match = tokenRegExp.exec(expFormat)) !== null) {
    var preMatch = expFormat.slice(index, match.index);
    index = tokenRegExp.lastIndex;
    quoteCount += Date._appendPreOrPostMatch(preMatch, regexp);
    if ((quoteCount%2) === 1) {
    regexp.append(match[0]);
    continue;
    }
    switch (match[0]) {
    case ‘dddd’: case ‘ddd’:
    case ‘MMMM’: case ‘MMM’:
    case ‘gg’: case ‘g’:
    regexp.append(“(\\D+)”);
    break;
    case ‘tt’: case ‘t’:
    regexp.append(“(\\D*)”);
    break;
    case ‘yyyy’:
    regexp.append(“(\\d{4})”);
    break;
    case ‘fff’:
    regexp.append(“(\\d{3})”);
    break;
    case ‘ff’:
    regexp.append(“(\\d{2})”);
    break;
    case ‘f’:
    regexp.append(“(\\d)”);
    break;
    case ‘dd’: case ‘d’:
    case ‘MM’: case ‘M’:
    case ‘yy’: case ‘y’:
    case ‘HH’: case ‘H’:
    case ‘hh’: case ‘h’:
    case ‘mm’: case ‘m’:
    case ‘ss’: case ‘s’:
    regexp.append(“(\\d\\d?)”);
    break;
    case ‘zzz’:
    regexp.append(“([+-]?\\d\\d?:\\d{2})”);
    break;
    case ‘zz’: case ‘z’:
    regexp.append(“([+-]?\\d\\d?)”);
    break;
    case ‘/’:
    regexp.append(“(\\” + dtf.DateSeparator + “)”);
    break;
    }
    Array.add(groups, match[0]);
    }
    Date._appendPreOrPostMatch(expFormat.slice(index), regexp);
    regexp.append(“$”);
    var regexpStr = regexp.toString().replace(/\s+/g, “\\s+”);
    var parseRegExp = {‘regExp’: regexpStr, ‘groups’: groups};
    dtf._parseRegExp[format] = parseRegExp;
    return parseRegExp;
    }
    Date._getTokenRegExp = function Date$_getTokenRegExp() {
    return /\/|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z|gg|g/g;
    }
    Date.parseLocale = function Date$parseLocale(value, formats) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String},
    {name: “formats”, mayBeNull: true, optional: true, parameterArray: true}
    ]);
    if (e) throw e;
    return Date._parse(value, Sys.CultureInfo.CurrentCulture, arguments);
    }
    Date.parseInvariant = function Date$parseInvariant(value, formats) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String},
    {name: “formats”, mayBeNull: true, optional: true, parameterArray: true}
    ]);
    if (e) throw e;
    return Date._parse(value, Sys.CultureInfo.InvariantCulture, arguments);
    }
    Date._parse = function Date$_parse(value, cultureInfo, args) {
    var i, l, date, format, formats, custom = false;
    for (i = 1, l = args.length; i < l; i++) { format = args[i]; if (format) { custom = true; date = Date._parseExact(value, format, cultureInfo); if (date) return date; } } if (! custom) { formats = cultureInfo._getDateTimeFormats(); for (i = 0, l = formats.length; i < l; i++) { date = Date._parseExact(value, formats[i], cultureInfo); if (date) return date; } } return null; } Date._parseExact = function Date$_parseExact(value, format, cultureInfo) { value = value.trim(); var dtf = cultureInfo.dateTimeFormat, parseInfo = Date._getParseRegExp(dtf, format), match = new RegExp(parseInfo.regExp).exec(value); if (match === null) return null; var groups = parseInfo.groups, era = null, year = null, month = null, date = null, weekDay = null, hour = 0, hourOffset, min = 0, sec = 0, msec = 0, tzMinOffset = null, pmHour = false; for (var j = 0, jl = groups.length; j < jl; j++) { var matchGroup = match[j+1]; if (matchGroup) { switch (groups[j]) { case 'dd': case 'd': date = parseInt(matchGroup, 10); if ((date < 1) || (date > 31)) return null;
    break;
    case ‘MMMM’:
    month = cultureInfo._getMonthIndex(matchGroup);
    if ((month < 0) || (month > 11)) return null;
    break;
    case ‘MMM’:
    month = cultureInfo._getAbbrMonthIndex(matchGroup);
    if ((month < 0) || (month > 11)) return null;
    break;
    case ‘M’: case ‘MM’:
    month = parseInt(matchGroup, 10) – 1;
    if ((month < 0) || (month > 11)) return null;
    break;
    case ‘y’: case ‘yy’:
    year = Date._expandYear(dtf,parseInt(matchGroup, 10));
    if ((year < 0) || (year > 9999)) return null;
    break;
    case ‘yyyy’:
    year = parseInt(matchGroup, 10);
    if ((year < 0) || (year > 9999)) return null;
    break;
    case ‘h’: case ‘hh’:
    hour = parseInt(matchGroup, 10);
    if (hour === 12) hour = 0;
    if ((hour < 0) || (hour > 11)) return null;
    break;
    case ‘H’: case ‘HH’:
    hour = parseInt(matchGroup, 10);
    if ((hour < 0) || (hour > 23)) return null;
    break;
    case ‘m’: case ‘mm’:
    min = parseInt(matchGroup, 10);
    if ((min < 0) || (min > 59)) return null;
    break;
    case ‘s’: case ‘ss’:
    sec = parseInt(matchGroup, 10);
    if ((sec < 0) || (sec > 59)) return null;
    break;
    case ‘tt’: case ‘t’:
    var upperToken = matchGroup.toUpperCase();
    pmHour = (upperToken === dtf.PMDesignator.toUpperCase());
    if (!pmHour && (upperToken !== dtf.AMDesignator.toUpperCase())) return null;
    break;
    case ‘f’:
    msec = parseInt(matchGroup, 10) * 100;
    if ((msec < 0) || (msec > 999)) return null;
    break;
    case ‘ff’:
    msec = parseInt(matchGroup, 10) * 10;
    if ((msec < 0) || (msec > 999)) return null;
    break;
    case ‘fff’:
    msec = parseInt(matchGroup, 10);
    if ((msec < 0) || (msec > 999)) return null;
    break;
    case ‘dddd’:
    weekDay = cultureInfo._getDayIndex(matchGroup);
    if ((weekDay < 0) || (weekDay > 6)) return null;
    break;
    case ‘ddd’:
    weekDay = cultureInfo._getAbbrDayIndex(matchGroup);
    if ((weekDay < 0) || (weekDay > 6)) return null;
    break;
    case ‘zzz’:
    var offsets = matchGroup.split(/:/);
    if (offsets.length !== 2) return null;
    hourOffset = parseInt(offsets[0], 10);
    if ((hourOffset < -12) || (hourOffset > 13)) return null;
    var minOffset = parseInt(offsets[1], 10);
    if ((minOffset < 0) || (minOffset > 59)) return null;
    tzMinOffset = (hourOffset * 60) + (matchGroup.startsWith(‘-‘)? -minOffset : minOffset);
    break;
    case ‘z’: case ‘zz’:
    hourOffset = parseInt(matchGroup, 10);
    if ((hourOffset < -12) || (hourOffset > 13)) return null;
    tzMinOffset = hourOffset * 60;
    break;
    case ‘g’: case ‘gg’:
    var eraName = matchGroup;
    if (!eraName || !dtf.eras) return null;
    eraName = eraName.toLowerCase().trim();
    for (var i = 0, l = dtf.eras.length; i < l; i += 4) { if (eraName === dtf.eras[i + 1].toLowerCase()) { era = i; break; } } if (era === null) return null; break; } } } var result = new Date(), defaultYear, convert = dtf.Calendar.convert; if (convert) { defaultYear = convert.fromGregorian(result)[0]; } else { defaultYear = result.getFullYear(); } if (year === null) { year = defaultYear; } else if (dtf.eras) { year += dtf.eras[(era || 0) + 3]; } if (month === null) { month = 0; } if (date === null) { date = 1; } if (convert) { result = convert.toGregorian(year, month, date); if (result === null) return null; } else { result.setFullYear(year, month, date); if (result.getDate() !== date) return null; if ((weekDay !== null) && (result.getDay() !== weekDay)) { return null; } } if (pmHour && (hour < 12)) { hour += 12; } result.setHours(hour, min, sec, msec); if (tzMinOffset !== null) { var adjustedMin = result.getMinutes() - (tzMinOffset + result.getTimezoneOffset()); result.setHours(result.getHours() + parseInt(adjustedMin/60, 10), adjustedMin%60); } return result; } Date.prototype.format = function Date$format(format) { /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String}
    ]);
    if (e) throw e;
    return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);
    }
    Date.prototype.localeFormat = function Date$localeFormat(format) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String}
    ]);
    if (e) throw e;
    return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);
    }
    Date.prototype._toFormattedString = function Date$_toFormattedString(format, cultureInfo) {
    var dtf = cultureInfo.dateTimeFormat,
    convert = dtf.Calendar.convert;
    if (!format || !format.length || (format === ‘i’)) {
    if (cultureInfo && cultureInfo.name.length) {
    if (convert) {
    return this._toFormattedString(dtf.FullDateTimePattern, cultureInfo);
    }
    else {
    var eraDate = new Date(this.getTime());
    var era = Date._getEra(this, dtf.eras);
    eraDate.setFullYear(Date._getEraYear(this, dtf, era));
    return eraDate.toLocaleString();
    }
    }
    else {
    return this.toString();
    }
    }
    var eras = dtf.eras,
    sortable = (format === “s”);
    format = Date._expandFormat(dtf, format);
    var ret = new Sys.StringBuilder();
    var hour;
    function addLeadingZero(num) {
    if (num < 10) { return '0' + num; } return num.toString(); } function addLeadingZeros(num) { if (num < 10) { return '00' + num; } if (num < 100) { return '0' + num; } return num.toString(); } function padYear(year) { if (year < 10) { return '000' + year; } else if (year < 100) { return '00' + year; } else if (year < 1000) { return '0' + year; } return year.toString(); } var foundDay, checkedDay, dayPartRegExp = /([^d]|^)(d|dd)([^d]|$)/g; function hasDay() { if (foundDay || checkedDay) { return foundDay; } foundDay = dayPartRegExp.test(format); checkedDay = true; return foundDay; } var quoteCount = 0, tokenRegExp = Date._getTokenRegExp(), converted; if (!sortable && convert) { converted = convert.fromGregorian(this); } for (;;) { var index = tokenRegExp.lastIndex; var ar = tokenRegExp.exec(format); var preMatch = format.slice(index, ar ? ar.index : format.length); quoteCount += Date._appendPreOrPostMatch(preMatch, ret); if (!ar) break; if ((quoteCount%2) === 1) { ret.append(ar[0]); continue; } function getPart(date, part) { if (converted) { return converted[part]; } switch (part) { case 0: return date.getFullYear(); case 1: return date.getMonth(); case 2: return date.getDate(); } } switch (ar[0]) { case "dddd": ret.append(dtf.DayNames[this.getDay()]); break; case "ddd": ret.append(dtf.AbbreviatedDayNames[this.getDay()]); break; case "dd": foundDay = true; ret.append(addLeadingZero(getPart(this, 2))); break; case "d": foundDay = true; ret.append(getPart(this, 2)); break; case "MMMM": ret.append((dtf.MonthGenitiveNames && hasDay()) ? dtf.MonthGenitiveNames[getPart(this, 1)] : dtf.MonthNames[getPart(this, 1)]); break; case "MMM": ret.append((dtf.AbbreviatedMonthGenitiveNames && hasDay()) ? dtf.AbbreviatedMonthGenitiveNames[getPart(this, 1)] : dtf.AbbreviatedMonthNames[getPart(this, 1)]); break; case "MM": ret.append(addLeadingZero(getPart(this, 1) + 1)); break; case "M": ret.append(getPart(this, 1) + 1); break; case "yyyy": ret.append(padYear(converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable))); break; case "yy": ret.append(addLeadingZero((converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable)) % 100)); break; case "y": ret.append((converted ? converted[0] : Date._getEraYear(this, dtf, Date._getEra(this, eras), sortable)) % 100); break; case "hh": hour = this.getHours() % 12; if (hour === 0) hour = 12; ret.append(addLeadingZero(hour)); break; case "h": hour = this.getHours() % 12; if (hour === 0) hour = 12; ret.append(hour); break; case "HH": ret.append(addLeadingZero(this.getHours())); break; case "H": ret.append(this.getHours()); break; case "mm": ret.append(addLeadingZero(this.getMinutes())); break; case "m": ret.append(this.getMinutes()); break; case "ss": ret.append(addLeadingZero(this.getSeconds())); break; case "s": ret.append(this.getSeconds()); break; case "tt": ret.append((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator); break; case "t": ret.append(((this.getHours() < 12) ? dtf.AMDesignator : dtf.PMDesignator).charAt(0)); break; case "f": ret.append(addLeadingZeros(this.getMilliseconds()).charAt(0)); break; case "ff": ret.append(addLeadingZeros(this.getMilliseconds()).substr(0, 2)); break; case "fff": ret.append(addLeadingZeros(this.getMilliseconds())); break; case "z": hour = this.getTimezoneOffset() / 60; ret.append(((hour <= 0) ? '+' : '-') + Math.floor(Math.abs(hour))); break; case "zz": hour = this.getTimezoneOffset() / 60; ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour)))); break; case "zzz": hour = this.getTimezoneOffset() / 60; ret.append(((hour <= 0) ? '+' : '-') + addLeadingZero(Math.floor(Math.abs(hour))) + ":" + addLeadingZero(Math.abs(this.getTimezoneOffset() % 60))); break; case "g": case "gg": if (dtf.eras) { ret.append(dtf.eras[Date._getEra(this, eras) + 1]); } break; case "/": ret.append(dtf.DateSeparator); break; } } return ret.toString(); } String.localeFormat = function String$localeFormat(format, args) { /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String},
    {name: “args”, mayBeNull: true, parameterArray: true}
    ]);
    if (e) throw e;
    return String._toFormattedString(true, arguments);
    }
    Number.parseLocale = function Number$parseLocale(value) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String}
    ], false);
    if (e) throw e;
    return Number._parse(value, Sys.CultureInfo.CurrentCulture);
    }
    Number.parseInvariant = function Number$parseInvariant(value) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “value”, type: String}
    ], false);
    if (e) throw e;
    return Number._parse(value, Sys.CultureInfo.InvariantCulture);
    }
    Number._parse = function Number$_parse(value, cultureInfo) {
    value = value.trim();

    if (value.match(/^[+-]?infinity$/i)) {
    return parseFloat(value);
    }
    if (value.match(/^0x[a-f0-9]+$/i)) {
    return parseInt(value);
    }
    var numFormat = cultureInfo.numberFormat;
    var signInfo = Number._parseNumberNegativePattern(value, numFormat, numFormat.NumberNegativePattern);
    var sign = signInfo[0];
    var num = signInfo[1];

    if ((sign === ”) && (numFormat.NumberNegativePattern !== 1)) {
    signInfo = Number._parseNumberNegativePattern(value, numFormat, 1);
    sign = signInfo[0];
    num = signInfo[1];
    }
    if (sign === ”) sign = ‘+’;

    var exponent;
    var intAndFraction;
    var exponentPos = num.indexOf(‘e’);
    if (exponentPos < 0) exponentPos = num.indexOf('E'); if (exponentPos < 0) { intAndFraction = num; exponent = null; } else { intAndFraction = num.substr(0, exponentPos); exponent = num.substr(exponentPos + 1); } var integer; var fraction; var decimalPos = intAndFraction.indexOf(numFormat.NumberDecimalSeparator); if (decimalPos < 0) { integer = intAndFraction; fraction = null; } else { integer = intAndFraction.substr(0, decimalPos); fraction = intAndFraction.substr(decimalPos + numFormat.NumberDecimalSeparator.length); } integer = integer.split(numFormat.NumberGroupSeparator).join(''); var altNumGroupSeparator = numFormat.NumberGroupSeparator.replace(/\u00A0/g, " "); if (numFormat.NumberGroupSeparator !== altNumGroupSeparator) { integer = integer.split(altNumGroupSeparator).join(''); } var p = sign + integer; if (fraction !== null) { p += '.' + fraction; } if (exponent !== null) { var expSignInfo = Number._parseNumberNegativePattern(exponent, numFormat, 1); if (expSignInfo[0] === '') { expSignInfo[0] = '+'; } p += 'e' + expSignInfo[0] + expSignInfo[1]; } if (p.match(/^[+-]?\d*\.?\d*(e[+-]?\d+)?$/)) { return parseFloat(p); } return Number.NaN; } Number._parseNumberNegativePattern = function Number$_parseNumberNegativePattern(value, numFormat, numberNegativePattern) { var neg = numFormat.NegativeSign; var pos = numFormat.PositiveSign; switch (numberNegativePattern) { case 4: neg = ' ' + neg; pos = ' ' + pos; case 3: if (value.endsWith(neg)) { return ['-', value.substr(0, value.length - neg.length)]; } else if (value.endsWith(pos)) { return ['+', value.substr(0, value.length - pos.length)]; } break; case 2: neg += ' '; pos += ' '; case 1: if (value.startsWith(neg)) { return ['-', value.substr(neg.length)]; } else if (value.startsWith(pos)) { return ['+', value.substr(pos.length)]; } break; case 0: if (value.startsWith('(') && value.endsWith(')')) { return ['-', value.substr(1, value.length - 2)]; } break; } return ['', value]; } Number.prototype.format = function Number$format(format) { ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String}
    ]);
    if (e) throw e;
    return this._toFormattedString(format, Sys.CultureInfo.InvariantCulture);
    }
    Number.prototype.localeFormat = function Number$localeFormat(format) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “format”, type: String}
    ]);
    if (e) throw e;
    return this._toFormattedString(format, Sys.CultureInfo.CurrentCulture);
    }
    Number.prototype._toFormattedString = function Number$_toFormattedString(format, cultureInfo) {
    if (!format || (format.length === 0) || (format === ‘i’)) {
    if (cultureInfo && (cultureInfo.name.length > 0)) {
    return this.toLocaleString();
    }
    else {
    return this.toString();
    }
    }

    var _percentPositivePattern = [“n %”, “n%”, “%n” ];
    var _percentNegativePattern = [“-n %”, “-n%”, “-%n”];
    var _numberNegativePattern = [“(n)”,”-n”,”- n”,”n-“,”n -“];
    var _currencyPositivePattern = [“$n”,”n$”,”$ n”,”n $”];
    var _currencyNegativePattern = [“($n)”,”-$n”,”$-n”,”$n-“,”(n$)”,”-n$”,”n-$”,”n$-“,”-n $”,”-$ n”,”n $-“,”$ n-“,”$ -n”,”n- $”,”($ n)”,”(n $)”];
    function zeroPad(str, count, left) {
    for (var l=str.length; l < count; l++) { str = (left ? ('0' + str) : (str + '0')); } return str; } function expandNumber(number, precision, groupSizes, sep, decimalChar) { var curSize = groupSizes[0]; var curGroupIndex = 1; var factor = Math.pow(10, precision); var rounded = (Math.round(number * factor) / factor); if (!isFinite(rounded)) { rounded = number; } number = rounded; var numberString = number.toString(); var right = ""; var exponent; var split = numberString.split(/e/i); numberString = split[0]; exponent = (split.length > 1 ? parseInt(split[1]) : 0);
    split = numberString.split(‘.’);
    numberString = split[0];
    right = split.length > 1 ? split[1] : “”;

    var l;
    if (exponent > 0) {
    right = zeroPad(right, exponent, false);
    numberString += right.slice(0, exponent);
    right = right.substr(exponent);
    }
    else if (exponent < 0) { exponent = -exponent; numberString = zeroPad(numberString, exponent+1, true); right = numberString.slice(-exponent, numberString.length) + right; numberString = numberString.slice(0, -exponent); } if (precision > 0) {
    if (right.length > precision) {
    right = right.slice(0, precision);
    }
    else {
    right = zeroPad(right, precision, false);
    }
    right = decimalChar + right;
    }
    else {
    right = “”;
    }
    var stringIndex = numberString.length-1;
    var ret = “”;
    while (stringIndex >= 0) {
    if (curSize === 0 || curSize > stringIndex) {
    if (ret.length > 0)
    return numberString.slice(0, stringIndex + 1) + sep + ret + right;
    else
    return numberString.slice(0, stringIndex + 1) + right;
    }
    if (ret.length > 0)
    ret = numberString.slice(stringIndex – curSize + 1, stringIndex+1) + sep + ret;
    else
    ret = numberString.slice(stringIndex – curSize + 1, stringIndex+1);
    stringIndex -= curSize;
    if (curGroupIndex < groupSizes.length) { curSize = groupSizes[curGroupIndex]; curGroupIndex++; } } return numberString.slice(0, stringIndex + 1) + sep + ret + right; } var nf = cultureInfo.numberFormat; var number = Math.abs(this); if (!format) format = "D"; var precision = -1; if (format.length > 1) precision = parseInt(format.slice(1), 10);
    var pattern;
    switch (format.charAt(0)) {
    case “d”:
    case “D”:
    pattern = ‘n’;
    if (precision !== -1) {
    number = zeroPad(“”+number, precision, true);
    }
    if (this < 0) number = -number; break; case "c": case "C": if (this < 0) pattern = _currencyNegativePattern[nf.CurrencyNegativePattern]; else pattern = _currencyPositivePattern[nf.CurrencyPositivePattern]; if (precision === -1) precision = nf.CurrencyDecimalDigits; number = expandNumber(Math.abs(this), precision, nf.CurrencyGroupSizes, nf.CurrencyGroupSeparator, nf.CurrencyDecimalSeparator); break; case "n": case "N": if (this < 0) pattern = _numberNegativePattern[nf.NumberNegativePattern]; else pattern = 'n'; if (precision === -1) precision = nf.NumberDecimalDigits; number = expandNumber(Math.abs(this), precision, nf.NumberGroupSizes, nf.NumberGroupSeparator, nf.NumberDecimalSeparator); break; case "p": case "P": if (this < 0) pattern = _percentNegativePattern[nf.PercentNegativePattern]; else pattern = _percentPositivePattern[nf.PercentPositivePattern]; if (precision === -1) precision = nf.PercentDecimalDigits; number = expandNumber(Math.abs(this) * 100, precision, nf.PercentGroupSizes, nf.PercentGroupSeparator, nf.PercentDecimalSeparator); break; default: throw Error.format(Sys.Res.formatBadFormatSpecifier); } var regex = /n|\$|-|%/g; var ret = ""; for (;;) { var index = regex.lastIndex; var ar = regex.exec(pattern); ret += pattern.slice(index, ar ? ar.index : pattern.length); if (!ar) break; switch (ar[0]) { case "n": ret += number; break; case "$": ret += nf.CurrencySymbol; break; case "-": if (/8/.test(number)) { ret += nf.NegativeSign; } break; case "%": ret += nf.PercentSymbol; break; } } return ret; } Sys.CultureInfo = function Sys$CultureInfo(name, numberFormat, dateTimeFormat) { ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “name”, type: String},
    {name: “numberFormat”, type: Object},
    {name: “dateTimeFormat”, type: Object}
    ]);
    if (e) throw e;
    this.name = name;
    this.numberFormat = numberFormat;
    this.dateTimeFormat = dateTimeFormat;
    }
    function Sys$CultureInfo$_getDateTimeFormats() {
    if (! this._dateTimeFormats) {
    var dtf = this.dateTimeFormat;
    this._dateTimeFormats =
    [ dtf.MonthDayPattern,
    dtf.YearMonthPattern,
    dtf.ShortDatePattern,
    dtf.ShortTimePattern,
    dtf.LongDatePattern,
    dtf.LongTimePattern,
    dtf.FullDateTimePattern,
    dtf.RFC1123Pattern,
    dtf.SortableDateTimePattern,
    dtf.UniversalSortableDateTimePattern ];
    }
    return this._dateTimeFormats;
    }
    function Sys$CultureInfo$_getIndex(value, a1, a2) {
    var upper = this._toUpper(value),
    i = Array.indexOf(a1, upper);
    if (i === -1) {
    i = Array.indexOf(a2, upper);
    }
    return i;
    }
    function Sys$CultureInfo$_getMonthIndex(value) {
    if (!this._upperMonths) {
    this._upperMonths = this._toUpperArray(this.dateTimeFormat.MonthNames);
    this._upperMonthsGenitive = this._toUpperArray(this.dateTimeFormat.MonthGenitiveNames);
    }
    return this._getIndex(value, this._upperMonths, this._upperMonthsGenitive);
    }
    function Sys$CultureInfo$_getAbbrMonthIndex(value) {
    if (!this._upperAbbrMonths) {
    this._upperAbbrMonths = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthNames);
    this._upperAbbrMonthsGenitive = this._toUpperArray(this.dateTimeFormat.AbbreviatedMonthGenitiveNames);
    }
    return this._getIndex(value, this._upperAbbrMonths, this._upperAbbrMonthsGenitive);
    }
    function Sys$CultureInfo$_getDayIndex(value) {
    if (!this._upperDays) {
    this._upperDays = this._toUpperArray(this.dateTimeFormat.DayNames);
    }
    return Array.indexOf(this._upperDays, this._toUpper(value));
    }
    function Sys$CultureInfo$_getAbbrDayIndex(value) {
    if (!this._upperAbbrDays) {
    this._upperAbbrDays = this._toUpperArray(this.dateTimeFormat.AbbreviatedDayNames);
    }
    return Array.indexOf(this._upperAbbrDays, this._toUpper(value));
    }
    function Sys$CultureInfo$_toUpperArray(arr) {
    var result = [];
    for (var i = 0, il = arr.length; i < il; i++) { result[i] = this._toUpper(arr[i]); } return result; } function Sys$CultureInfo$_toUpper(value) { return value.split("\u00A0").join(' ').toUpperCase(); } Sys.CultureInfo.prototype = { _getDateTimeFormats: Sys$CultureInfo$_getDateTimeFormats, _getIndex: Sys$CultureInfo$_getIndex, _getMonthIndex: Sys$CultureInfo$_getMonthIndex, _getAbbrMonthIndex: Sys$CultureInfo$_getAbbrMonthIndex, _getDayIndex: Sys$CultureInfo$_getDayIndex, _getAbbrDayIndex: Sys$CultureInfo$_getAbbrDayIndex, _toUpperArray: Sys$CultureInfo$_toUpperArray, _toUpper: Sys$CultureInfo$_toUpper } Sys.CultureInfo.registerClass('Sys.CultureInfo'); Sys.CultureInfo._parse = function Sys$CultureInfo$_parse(value) { var dtf = value.dateTimeFormat; if (dtf && !dtf.eras) { dtf.eras = value.eras; } return new Sys.CultureInfo(value.name, value.numberFormat, dtf); } Sys.CultureInfo.InvariantCulture = Sys.CultureInfo._parse({"name":"","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":true,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"\u00A4","NaNSymbol":"NaN","CurrencyNegativePattern":0,"NumberNegativePattern":1,"PercentPositivePattern":0,"PercentNegativePattern":0,"NegativeInfinitySymbol":"-Infinity","NegativeSign":"-","NumberDecimalDigits":2,"NumberDecimalSeparator":".","NumberGroupSeparator":",","CurrencyPositivePattern":0,"PositiveInfinitySymbol":"Infinity","PositiveSign":"+","PercentDecimalDigits":2,"PercentDecimalSeparator":".","PercentGroupSeparator":",","PercentSymbol":"%","PerMilleSymbol":"\u2030","NativeDigits":["0","1","2","3","4","5","6","7","8","9"],"DigitSubstitution":1},"dateTimeFormat":{"AMDesignator":"AM","Calendar":{"MinSupportedDateTime":"@[email protected]","MaxSupportedDateTime":"@[email protected]","AlgorithmType":1,"CalendarType":1,"Eras":[1],"TwoDigitYearMax":2029,"IsReadOnly":true},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, dd MMMM yyyy HH:mm:ss","LongDatePattern":"dddd, dd MMMM yyyy","LongTimePattern":"HH:mm:ss","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"MM/dd/yyyy","ShortTimePattern":"HH:mm","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"yyyy MMMM","AbbreviatedDayNames":["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],"ShortestDayNames":["Su","Mo","Tu","We","Th","Fr","Sa"],"DayNames":["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"AbbreviatedMonthNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthNames":["January","February","March","April","May","June","July","August","September","October","November","December",""],"IsReadOnly":true,"NativeCalendarName":"Gregorian Calendar","AbbreviatedMonthGenitiveNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthGenitiveNames":["January","February","March","April","May","June","July","August","September","October","November","December",""]},"eras":[1,"A.D.",null,0]}); if (typeof(__cultureInfo) === "object") { Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse(__cultureInfo); delete __cultureInfo; } else { Sys.CultureInfo.CurrentCulture = Sys.CultureInfo._parse({"name":"en-US","numberFormat":{"CurrencyDecimalDigits":2,"CurrencyDecimalSeparator":".","IsReadOnly":false,"CurrencyGroupSizes":[3],"NumberGroupSizes":[3],"PercentGroupSizes":[3],"CurrencyGroupSeparator":",","CurrencySymbol":"$","NaNSymbol":"NaN","CurrencyNegativePattern":0,"NumberNegativePattern":1,"PercentPositivePattern":0,"PercentNegativePattern":0,"NegativeInfinitySymbol":"-Infinity","NegativeSign":"-","NumberDecimalDigits":2,"NumberDecimalSeparator":".","NumberGroupSeparator":",","CurrencyPositivePattern":0,"PositiveInfinitySymbol":"Infinity","PositiveSign":"+","PercentDecimalDigits":2,"PercentDecimalSeparator":".","PercentGroupSeparator":",","PercentSymbol":"%","PerMilleSymbol":"\u2030","NativeDigits":["0","1","2","3","4","5","6","7","8","9"],"DigitSubstitution":1},"dateTimeFormat":{"AMDesignator":"AM","Calendar":{"MinSupportedDateTime":"@[email protected]","MaxSupportedDateTime":"@[email protected]","AlgorithmType":1,"CalendarType":1,"Eras":[1],"TwoDigitYearMax":2029,"IsReadOnly":false},"DateSeparator":"/","FirstDayOfWeek":0,"CalendarWeekRule":0,"FullDateTimePattern":"dddd, MMMM dd, yyyy h:mm:ss tt","LongDatePattern":"dddd, MMMM dd, yyyy","LongTimePattern":"h:mm:ss tt","MonthDayPattern":"MMMM dd","PMDesignator":"PM","RFC1123Pattern":"ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'","ShortDatePattern":"M/d/yyyy","ShortTimePattern":"h:mm tt","SortableDateTimePattern":"yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss","TimeSeparator":":","UniversalSortableDateTimePattern":"yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'","YearMonthPattern":"MMMM, yyyy","AbbreviatedDayNames":["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],"ShortestDayNames":["Su","Mo","Tu","We","Th","Fr","Sa"],"DayNames":["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],"AbbreviatedMonthNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthNames":["January","February","March","April","May","June","July","August","September","October","November","December",""],"IsReadOnly":false,"NativeCalendarName":"Gregorian Calendar","AbbreviatedMonthGenitiveNames":["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec",""],"MonthGenitiveNames":["January","February","March","April","May","June","July","August","September","October","November","December",""]},"eras":[1,"A.D.",null,0]}); } Type.registerNamespace('Sys.Serialization'); Sys.Serialization.JavaScriptSerializer = function Sys$Serialization$JavaScriptSerializer() { /// if (arguments.length !== 0) throw Error.parameterCount();
    }
    Sys.Serialization.JavaScriptSerializer.registerClass(‘Sys.Serialization.JavaScriptSerializer’);
    Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs = [];
    Sys.Serialization.JavaScriptSerializer._charsToEscape = [];
    Sys.Serialization.JavaScriptSerializer._dateRegEx = new RegExp(‘(^|[^\\\\])\\”\\\\/Date\\((-?9+)(?:[a-zA-Z]|(?:\\+|-)2{4})?\\)\\\\/\\”‘, ‘g’);
    Sys.Serialization.JavaScriptSerializer._escapeChars = {};
    Sys.Serialization.JavaScriptSerializer._escapeRegEx = new RegExp(‘[“\\\\\\x00-\\x1F]’, ‘i’);
    Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal = new RegExp(‘[“\\\\\\x00-\\x1F]’, ‘g’);
    Sys.Serialization.JavaScriptSerializer._jsonRegEx = new RegExp(‘[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]’, ‘g’);
    Sys.Serialization.JavaScriptSerializer._jsonStringRegEx = new RegExp(‘”(\\\\.|[^”\\\\])*”‘, ‘g’);
    Sys.Serialization.JavaScriptSerializer._serverTypeFieldName = ‘__type’;
    Sys.Serialization.JavaScriptSerializer._init = function Sys$Serialization$JavaScriptSerializer$_init() {
    var replaceChars = [‘\\u0000′,’\\u0001′,’\\u0002′,’\\u0003′,’\\u0004′,’\\u0005′,’\\u0006′,’\\u0007’,
    ‘\\b’,’\\t’,’\\n’,’\\u000b’,’\\f’,’\\r’,’\\u000e’,’\\u000f’,’\\u0010′,’\\u0011′,
    ‘\\u0012′,’\\u0013′,’\\u0014′,’\\u0015′,’\\u0016′,’\\u0017′,’\\u0018′,’\\u0019’,
    ‘\\u001a’,’\\u001b’,’\\u001c’,’\\u001d’,’\\u001e’,’\\u001f’];
    Sys.Serialization.JavaScriptSerializer._charsToEscape[0] = ‘\\’;
    Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[‘\\’] = new RegExp(‘\\\\’, ‘g’);
    Sys.Serialization.JavaScriptSerializer._escapeChars[‘\\’] = ‘\\\\’;
    Sys.Serialization.JavaScriptSerializer._charsToEscape[1] = ‘”‘;
    Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[‘”‘] = new RegExp(‘”‘, ‘g’);
    Sys.Serialization.JavaScriptSerializer._escapeChars[‘”‘] = ‘\\”‘;
    for (var i = 0; i < 32; i++) { var c = String.fromCharCode(i); Sys.Serialization.JavaScriptSerializer._charsToEscape[i+2] = c; Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c] = new RegExp(c, 'g'); Sys.Serialization.JavaScriptSerializer._escapeChars[c] = replaceChars[i]; } } Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeBooleanWithBuilder(object, stringBuilder) { stringBuilder.append(object.toString()); } Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeNumberWithBuilder(object, stringBuilder) { if (isFinite(object)) { stringBuilder.append(String(object)); } else { throw Error.invalidOperation(Sys.Res.cannotSerializeNonFiniteNumbers); } } Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeStringWithBuilder(string, stringBuilder) { stringBuilder.append('"'); if (Sys.Serialization.JavaScriptSerializer._escapeRegEx.test(string)) { if (Sys.Serialization.JavaScriptSerializer._charsToEscape.length === 0) { Sys.Serialization.JavaScriptSerializer._init(); } if (string.length < 128) { string = string.replace(Sys.Serialization.JavaScriptSerializer._escapeRegExGlobal, function(x) { return Sys.Serialization.JavaScriptSerializer._escapeChars[x]; }); } else { for (var i = 0; i < 34; i++) { var c = Sys.Serialization.JavaScriptSerializer._charsToEscape[i]; if (string.indexOf(c) !== -1) { if (Sys.Browser.agent === Sys.Browser.Opera || Sys.Browser.agent === Sys.Browser.FireFox) { string = string.split(c).join(Sys.Serialization.JavaScriptSerializer._escapeChars[c]); } else { string = string.replace(Sys.Serialization.JavaScriptSerializer._charsToEscapeRegExs[c], Sys.Serialization.JavaScriptSerializer._escapeChars[c]); } } } } } stringBuilder.append(string); stringBuilder.append('"'); } Sys.Serialization.JavaScriptSerializer._serializeWithBuilder = function Sys$Serialization$JavaScriptSerializer$_serializeWithBuilder(object, stringBuilder, sort, prevObjects) { var i; switch (typeof object) { case 'object': if (object) { if (prevObjects){ for( var j = 0; j < prevObjects.length; j++) { if (prevObjects[j] === object) { throw Error.invalidOperation(Sys.Res.cannotSerializeObjectWithCycle); } } } else { prevObjects = new Array(); } try { Array.add(prevObjects, object); if (Number.isInstanceOfType(object)){ Sys.Serialization.JavaScriptSerializer._serializeNumberWithBuilder(object, stringBuilder); } else if (Boolean.isInstanceOfType(object)){ Sys.Serialization.JavaScriptSerializer._serializeBooleanWithBuilder(object, stringBuilder); } else if (String.isInstanceOfType(object)){ Sys.Serialization.JavaScriptSerializer._serializeStringWithBuilder(object, stringBuilder); } else if (Array.isInstanceOfType(object)) { stringBuilder.append('['); for (i = 0; i < object.length; ++i) { if (i > 0) {
    stringBuilder.append(‘,’);
    }
    Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object[i], stringBuilder,false,prevObjects);
    }
    stringBuilder.append(‘]’);
    }
    else {
    if (Date.isInstanceOfType(object)) {
    stringBuilder.append(‘”\\/Date(‘);
    stringBuilder.append(object.getTime());
    stringBuilder.append(‘)\\/”‘);
    break;
    }
    var properties = [];
    var propertyCount = 0;
    for (var name in object) {
    if (name.startsWith(‘$’)) {
    continue;
    }
    if (name === Sys.Serialization.JavaScriptSerializer._serverTypeFieldName && propertyCount !== 0){
    properties[propertyCount++] = properties[0];
    properties[0] = name;
    }
    else{
    properties[propertyCount++] = name;
    }
    }
    if (sort) properties.sort();
    stringBuilder.append(‘{‘);
    var needComma = false;

    for (i=0; i /// ///
    var e = Function._validateParams(arguments, [
    {name: “object”, mayBeNull: true}
    ]);
    if (e) throw e;
    var stringBuilder = new Sys.StringBuilder();
    Sys.Serialization.JavaScriptSerializer._serializeWithBuilder(object, stringBuilder, false);
    return stringBuilder.toString();
    }
    Sys.Serialization.JavaScriptSerializer.deserialize = function Sys$Serialization$JavaScriptSerializer$deserialize(data, secure) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “data”, type: String},
    {name: “secure”, type: Boolean, optional: true}
    ]);
    if (e) throw e;

    if (data.length === 0) throw Error.argument(‘data’, Sys.Res.cannotDeserializeEmptyString);
    try {
    var exp = data.replace(Sys.Serialization.JavaScriptSerializer._dateRegEx, “new Date($2)”);

    if (secure && Sys.Serialization.JavaScriptSerializer._jsonRegEx.test(
    exp.replace(Sys.Serialization.JavaScriptSerializer._jsonStringRegEx, ”))) throw null;
    return eval(‘(‘ + exp + ‘)’);
    }
    catch (e) {
    throw Error.argument(‘data’, Sys.Res.cannotDeserializeInvalidJson);
    }
    }
    Type.registerNamespace(‘Sys.UI’);

    Sys.EventHandlerList = function Sys$EventHandlerList() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._list = {};
    }
    function Sys$EventHandlerList$_addHandler(id, handler) {
    Array.add(this._getEvent(id, true), handler);
    }
    function Sys$EventHandlerList$addHandler(id, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “id”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    this._addHandler(id, handler);
    }
    function Sys$EventHandlerList$_removeHandler(id, handler) {
    var evt = this._getEvent(id);
    if (!evt) return;
    Array.remove(evt, handler);
    }
    function Sys$EventHandlerList$removeHandler(id, handler) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “id”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    this._removeHandler(id, handler);
    }
    function Sys$EventHandlerList$getHandler(id) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “id”, type: String}
    ]);
    if (e) throw e;
    var evt = this._getEvent(id);
    if (!evt || (evt.length === 0)) return null;
    evt = Array.clone(evt);
    return function(source, args) {
    for (var i = 0, l = evt.length; i < l; i++) { evt[i](source, args); } }; } function Sys$EventHandlerList$_getEvent(id, create) { if (!this._list[id]) { if (!create) return null; this._list[id] = []; } return this._list[id]; } Sys.EventHandlerList.prototype = { _addHandler: Sys$EventHandlerList$_addHandler, addHandler: Sys$EventHandlerList$addHandler, _removeHandler: Sys$EventHandlerList$_removeHandler, removeHandler: Sys$EventHandlerList$removeHandler, getHandler: Sys$EventHandlerList$getHandler, _getEvent: Sys$EventHandlerList$_getEvent } Sys.EventHandlerList.registerClass('Sys.EventHandlerList'); Sys.CommandEventArgs = function Sys$CommandEventArgs(commandName, commandArgument, commandSource) { /// /// /// /// var e = Function._validateParams(arguments, [
    {name: “commandName”, type: String},
    {name: “commandArgument”, mayBeNull: true},
    {name: “commandSource”, mayBeNull: true}
    ]);
    if (e) throw e;
    Sys.CommandEventArgs.initializeBase(this);
    this._commandName = commandName;
    this._commandArgument = commandArgument;
    this._commandSource = commandSource;
    }
    function Sys$CommandEventArgs$get_commandName() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._commandName;
    }
    function Sys$CommandEventArgs$get_commandArgument() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._commandArgument;
    }
    function Sys$CommandEventArgs$get_commandSource() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._commandSource;
    }
    Sys.CommandEventArgs.prototype = {
    _commandName: null,
    _commandArgument: null,
    _commandSource: null,
    get_commandName: Sys$CommandEventArgs$get_commandName,
    get_commandArgument: Sys$CommandEventArgs$get_commandArgument,
    get_commandSource: Sys$CommandEventArgs$get_commandSource
    }
    Sys.CommandEventArgs.registerClass(“Sys.CommandEventArgs”, Sys.CancelEventArgs);

    Sys.INotifyPropertyChange = function Sys$INotifyPropertyChange() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$INotifyPropertyChange$add_propertyChanged(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$INotifyPropertyChange$remove_propertyChanged(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    Sys.INotifyPropertyChange.prototype = {
    add_propertyChanged: Sys$INotifyPropertyChange$add_propertyChanged,
    remove_propertyChanged: Sys$INotifyPropertyChange$remove_propertyChanged
    }
    Sys.INotifyPropertyChange.registerInterface(‘Sys.INotifyPropertyChange’);

    Sys.PropertyChangedEventArgs = function Sys$PropertyChangedEventArgs(propertyName) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “propertyName”, type: String}
    ]);
    if (e) throw e;
    Sys.PropertyChangedEventArgs.initializeBase(this);
    this._propertyName = propertyName;
    }

    function Sys$PropertyChangedEventArgs$get_propertyName() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._propertyName;
    }
    Sys.PropertyChangedEventArgs.prototype = {
    get_propertyName: Sys$PropertyChangedEventArgs$get_propertyName
    }
    Sys.PropertyChangedEventArgs.registerClass(‘Sys.PropertyChangedEventArgs’, Sys.EventArgs);

    Sys.INotifyDisposing = function Sys$INotifyDisposing() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$INotifyDisposing$add_disposing(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$INotifyDisposing$remove_disposing(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    Sys.INotifyDisposing.prototype = {
    add_disposing: Sys$INotifyDisposing$add_disposing,
    remove_disposing: Sys$INotifyDisposing$remove_disposing
    }
    Sys.INotifyDisposing.registerInterface(“Sys.INotifyDisposing”);

    Sys.Component = function Sys$Component() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (Sys.Application) Sys.Application.registerDisposableObject(this);
    }
    function Sys$Component$get_events() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._events) {
    this._events = new Sys.EventHandlerList();
    }
    return this._events;
    }
    function Sys$Component$get_id() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._id;
    }
    function Sys$Component$set_id(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    if (this._idSet) throw Error.invalidOperation(Sys.Res.componentCantSetIdTwice);
    this._idSet = true;
    var oldId = this.get_id();
    if (oldId && Sys.Application.findComponent(oldId)) throw Error.invalidOperation(Sys.Res.componentCantSetIdAfterAddedToApp);
    this._id = value;
    }
    function Sys$Component$get_isInitialized() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._initialized;
    }
    function Sys$Component$get_isUpdating() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._updating;
    }
    function Sys$Component$add_disposing(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().addHandler(“disposing”, handler);
    }
    function Sys$Component$remove_disposing(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().removeHandler(“disposing”, handler);
    }
    function Sys$Component$add_propertyChanged(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().addHandler(“propertyChanged”, handler);
    }
    function Sys$Component$remove_propertyChanged(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().removeHandler(“propertyChanged”, handler);
    }
    function Sys$Component$beginUpdate() {
    this._updating = true;
    }
    function Sys$Component$dispose() {
    if (this._events) {
    var handler = this._events.getHandler(“disposing”);
    if (handler) {
    handler(this, Sys.EventArgs.Empty);
    }
    }
    delete this._events;
    Sys.Application.unregisterDisposableObject(this);
    Sys.Application.removeComponent(this);
    }
    function Sys$Component$endUpdate() {
    this._updating = false;
    if (!this._initialized) this.initialize();
    this.updated();
    }
    function Sys$Component$initialize() {
    this._initialized = true;
    }
    function Sys$Component$raisePropertyChanged(propertyName) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “propertyName”, type: String}
    ]);
    if (e) throw e;
    if (!this._events) return;
    var handler = this._events.getHandler(“propertyChanged”);
    if (handler) {
    handler(this, new Sys.PropertyChangedEventArgs(propertyName));
    }
    }
    function Sys$Component$updated() {
    }
    Sys.Component.prototype = {
    _id: null,
    _idSet: false,
    _initialized: false,
    _updating: false,
    get_events: Sys$Component$get_events,
    get_id: Sys$Component$get_id,
    set_id: Sys$Component$set_id,
    get_isInitialized: Sys$Component$get_isInitialized,
    get_isUpdating: Sys$Component$get_isUpdating,
    add_disposing: Sys$Component$add_disposing,
    remove_disposing: Sys$Component$remove_disposing,
    add_propertyChanged: Sys$Component$add_propertyChanged,
    remove_propertyChanged: Sys$Component$remove_propertyChanged,
    beginUpdate: Sys$Component$beginUpdate,
    dispose: Sys$Component$dispose,
    endUpdate: Sys$Component$endUpdate,
    initialize: Sys$Component$initialize,
    raisePropertyChanged: Sys$Component$raisePropertyChanged,
    updated: Sys$Component$updated
    }
    Sys.Component.registerClass(‘Sys.Component’, null, Sys.IDisposable, Sys.INotifyPropertyChange, Sys.INotifyDisposing);
    function Sys$Component$_setProperties(target, properties) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “target”},
    {name: “properties”}
    ]);
    if (e) throw e;
    var current;
    var targetType = Object.getType(target);
    var isObject = (targetType === Object) || (targetType === Sys.UI.DomElement);
    var isComponent = Sys.Component.isInstanceOfType(target) && !target.get_isUpdating();
    if (isComponent) target.beginUpdate();
    for (var name in properties) {
    var val = properties[name];
    var getter = isObject ? null : target[“get_” + name];
    if (isObject || typeof(getter) !== ‘function’) {
    var targetVal = target[name];
    if (!isObject && typeof(targetVal) === ‘undefined’) throw Error.invalidOperation(String.format(Sys.Res.propertyUndefined, name));
    if (!val || (typeof(val) !== ‘object’) || (isObject && !targetVal)) {
    target[name] = val;
    }
    else {
    Sys$Component$_setProperties(targetVal, val);
    }
    }
    else {
    var setter = target[“set_” + name];
    if (typeof(setter) === ‘function’) {
    setter.apply(target, [val]);
    }
    else if (val instanceof Array) {
    current = getter.apply(target);
    if (!(current instanceof Array)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNotAnArray, name));
    for (var i = 0, j = current.length, l= val.length; i < l; i++, j++) { current[j] = val[i]; } } else if ((typeof(val) === 'object') && (Object.getType(val) === Object)) { current = getter.apply(target); if ((typeof(current) === 'undefined') || (current === null)) throw new Error.invalidOperation(String.format(Sys.Res.propertyNullOrUndefined, name)); Sys$Component$_setProperties(current, val); } else { throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name)); } } } if (isComponent) target.endUpdate(); } function Sys$Component$_setReferences(component, references) { for (var name in references) { var setter = component["set_" + name]; var reference = $find(references[name]); if (typeof(setter) !== 'function') throw new Error.invalidOperation(String.format(Sys.Res.propertyNotWritable, name)); if (!reference) throw Error.invalidOperation(String.format(Sys.Res.referenceNotFound, references[name])); setter.apply(component, [reference]); } } var $create = Sys.Component.create = function Sys$Component$create(type, properties, events, references, element) { /// /// /// /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “type”, type: Type},
    {name: “properties”, mayBeNull: true, optional: true},
    {name: “events”, mayBeNull: true, optional: true},
    {name: “references”, mayBeNull: true, optional: true},
    {name: “element”, mayBeNull: true, domElement: true, optional: true}
    ]);
    if (e) throw e;
    if (!type.inheritsFrom(Sys.Component)) {
    throw Error.argument(‘type’, String.format(Sys.Res.createNotComponent, type.getName()));
    }
    if (type.inheritsFrom(Sys.UI.Behavior) || type.inheritsFrom(Sys.UI.Control)) {
    if (!element) throw Error.argument(‘element’, Sys.Res.createNoDom);
    }
    else if (element) throw Error.argument(‘element’, Sys.Res.createComponentOnDom);
    var component = (element ? new type(element): new type());
    var app = Sys.Application;
    var creatingComponents = app.get_isCreatingComponents();
    component.beginUpdate();
    if (properties) {
    Sys$Component$_setProperties(component, properties);
    }
    if (events) {
    for (var name in events) {
    if (!(component[“add_” + name] instanceof Function)) throw new Error.invalidOperation(String.format(Sys.Res.undefinedEvent, name));
    if (!(events[name] instanceof Function)) throw new Error.invalidOperation(Sys.Res.eventHandlerNotFunction);
    component[“add_” + name](events[name]);
    }
    }
    if (component.get_id()) {
    app.addComponent(component);
    }
    if (creatingComponents) {
    app._createdComponents[app._createdComponents.length] = component;
    if (references) {
    app._addComponentToSecondPass(component, references);
    }
    else {
    component.endUpdate();
    }
    }
    else {
    if (references) {
    Sys$Component$_setReferences(component, references);
    }
    component.endUpdate();
    }
    return component;
    }

    Sys.UI.MouseButton = function Sys$UI$MouseButton() {
    ///

    ///
    ///
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.UI.MouseButton.prototype = {
    leftButton: 0,
    middleButton: 1,
    rightButton: 2
    }
    Sys.UI.MouseButton.registerEnum(“Sys.UI.MouseButton”);

    Sys.UI.Key = function Sys$UI$Key() {
    ///

    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.UI.Key.prototype = {
    backspace: 8,
    tab: 9,
    enter: 13,
    esc: 27,
    space: 32,
    pageUp: 33,
    pageDown: 34,
    end: 35,
    home: 36,
    left: 37,
    up: 38,
    right: 39,
    down: 40,
    del: 127
    }
    Sys.UI.Key.registerEnum(“Sys.UI.Key”);

    Sys.UI.Point = function Sys$UI$Point(x, y) {
    ///

    /// /// ///
    ///
    var e = Function._validateParams(arguments, [
    {name: “x”, type: Number, integer: true},
    {name: “y”, type: Number, integer: true}
    ]);
    if (e) throw e;
    this.x = x;
    this.y = y;
    }
    Sys.UI.Point.registerClass(‘Sys.UI.Point’);

    Sys.UI.Bounds = function Sys$UI$Bounds(x, y, width, height) {
    ///

    /// /// /// /// ///
    ///
    ///
    ///
    var e = Function._validateParams(arguments, [
    {name: “x”, type: Number, integer: true},
    {name: “y”, type: Number, integer: true},
    {name: “width”, type: Number, integer: true},
    {name: “height”, type: Number, integer: true}
    ]);
    if (e) throw e;
    this.x = x;
    this.y = y;
    this.height = height;
    this.width = width;
    }
    Sys.UI.Bounds.registerClass(‘Sys.UI.Bounds’);

    Sys.UI.DomEvent = function Sys$UI$DomEvent(eventObject) {
    ///

    /// ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    var e = Function._validateParams(arguments, [
    {name: “eventObject”}
    ]);
    if (e) throw e;
    var ev = eventObject;
    var etype = this.type = ev.type.toLowerCase();
    this.rawEvent = ev;
    this.altKey = ev.altKey;
    if (typeof(ev.button) !== ‘undefined’) {
    this.button = (typeof(ev.which) !== ‘undefined’) ? ev.button :
    (ev.button === 4) ? Sys.UI.MouseButton.middleButton :
    (ev.button === 2) ? Sys.UI.MouseButton.rightButton :
    Sys.UI.MouseButton.leftButton;
    }
    if (etype === ‘keypress’) {
    this.charCode = ev.charCode || ev.keyCode;
    }
    else if (ev.keyCode && (ev.keyCode === 46)) {
    this.keyCode = 127;
    }
    else {
    this.keyCode = ev.keyCode;
    }
    this.clientX = ev.clientX;
    this.clientY = ev.clientY;
    this.ctrlKey = ev.ctrlKey;
    this.target = ev.target ? ev.target : ev.srcElement;
    if (!etype.startsWith(‘key’)) {
    if ((typeof(ev.offsetX) !== ‘undefined’) && (typeof(ev.offsetY) !== ‘undefined’)) {
    this.offsetX = ev.offsetX;
    this.offsetY = ev.offsetY;
    }
    else if (this.target && (this.target.nodeType !== 3) && (typeof(ev.clientX) === ‘number’)) {
    var loc = Sys.UI.DomElement.getLocation(this.target);
    var w = Sys.UI.DomElement._getWindow(this.target);
    this.offsetX = (w.pageXOffset || 0) + ev.clientX – loc.x;
    this.offsetY = (w.pageYOffset || 0) + ev.clientY – loc.y;
    }
    }
    this.screenX = ev.screenX;
    this.screenY = ev.screenY;
    this.shiftKey = ev.shiftKey;
    }
    function Sys$UI$DomEvent$preventDefault() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (this.rawEvent.preventDefault) {
    this.rawEvent.preventDefault();
    }
    else if (window.event) {
    this.rawEvent.returnValue = false;
    }
    }
    function Sys$UI$DomEvent$stopPropagation() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (this.rawEvent.stopPropagation) {
    this.rawEvent.stopPropagation();
    }
    else if (window.event) {
    this.rawEvent.cancelBubble = true;
    }
    }
    Sys.UI.DomEvent.prototype = {
    preventDefault: Sys$UI$DomEvent$preventDefault,
    stopPropagation: Sys$UI$DomEvent$stopPropagation
    }
    Sys.UI.DomEvent.registerClass(‘Sys.UI.DomEvent’);
    var $addHandler = Sys.UI.DomEvent.addHandler = function Sys$UI$DomEvent$addHandler(element, eventName, handler, autoRemove) {
    ///

    /// /// /// /// var e = Function._validateParams(arguments, [
    {name: “element”},
    {name: “eventName”, type: String},
    {name: “handler”, type: Function},
    {name: “autoRemove”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    Sys.UI.DomEvent._ensureDomNode(element);
    if (eventName === “error”) throw Error.invalidOperation(Sys.Res.addHandlerCantBeUsedForError);
    if (!element._events) {
    element._events = {};
    }
    var eventCache = element._events[eventName];
    if (!eventCache) {
    element._events[eventName] = eventCache = [];
    }
    var browserHandler;
    if (element.addEventListener) {
    browserHandler = function(e) {
    return handler.call(element, new Sys.UI.DomEvent(e));
    }
    element.addEventListener(eventName, browserHandler, false);
    }
    else if (element.attachEvent) {
    browserHandler = function() {
    var e = {};
    try {e = Sys.UI.DomElement._getWindow(element).event} catch(ex) {}
    return handler.call(element, new Sys.UI.DomEvent(e));
    }
    element.attachEvent(‘on’ + eventName, browserHandler);
    }
    eventCache[eventCache.length] = {handler: handler, browserHandler: browserHandler, autoRemove: autoRemove };
    if (autoRemove) {
    var d = element.dispose;
    if (d !== Sys.UI.DomEvent._disposeHandlers) {
    element.dispose = Sys.UI.DomEvent._disposeHandlers;
    if (typeof(d) !== “undefined”) {
    element._chainDispose = d;
    }
    }
    }
    }
    var $addHandlers = Sys.UI.DomEvent.addHandlers = function Sys$UI$DomEvent$addHandlers(element, events, handlerOwner, autoRemove) {
    ///

    /// /// /// /// var e = Function._validateParams(arguments, [
    {name: “element”},
    {name: “events”, type: Object},
    {name: “handlerOwner”, optional: true},
    {name: “autoRemove”, type: Boolean, optional: true}
    ]);
    if (e) throw e;
    Sys.UI.DomEvent._ensureDomNode(element);
    for (var name in events) {
    var handler = events[name];
    if (typeof(handler) !== ‘function’) throw Error.invalidOperation(Sys.Res.cantAddNonFunctionhandler);
    if (handlerOwner) {
    handler = Function.createDelegate(handlerOwner, handler);
    }
    $addHandler(element, name, handler, autoRemove || false);
    }
    }
    var $clearHandlers = Sys.UI.DomEvent.clearHandlers = function Sys$UI$DomEvent$clearHandlers(element) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “element”}
    ]);
    if (e) throw e;
    Sys.UI.DomEvent._ensureDomNode(element);
    Sys.UI.DomEvent._clearHandlers(element, false);
    }
    Sys.UI.DomEvent._clearHandlers = function Sys$UI$DomEvent$_clearHandlers(element, autoRemoving) {
    if (element._events) {
    var cache = element._events;
    for (var name in cache) {
    var handlers = cache[name];
    for (var i = handlers.length – 1; i >= 0; i–) {
    var entry = handlers[i];
    if (!autoRemoving || entry.autoRemove) {
    $removeHandler(element, name, entry.handler);
    }
    }
    }
    element._events = null;
    }
    }
    Sys.UI.DomEvent._disposeHandlers = function Sys$UI$DomEvent$_disposeHandlers() {
    Sys.UI.DomEvent._clearHandlers(this, true);
    var d = this._chainDispose, type = typeof(d);
    if (type !== “undefined”) {
    this.dispose = d;
    this._chainDispose = null;
    if (type === “function”) {
    this.dispose();
    }
    }
    }
    var $removeHandler = Sys.UI.DomEvent.removeHandler = function Sys$UI$DomEvent$removeHandler(element, eventName, handler) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “element”},
    {name: “eventName”, type: String},
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    Sys.UI.DomEvent._removeHandler(element, eventName, handler);
    }
    Sys.UI.DomEvent._removeHandler = function Sys$UI$DomEvent$_removeHandler(element, eventName, handler) {
    Sys.UI.DomEvent._ensureDomNode(element);
    var browserHandler = null;
    if ((typeof(element._events) !== ‘object’) || !element._events) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);
    var cache = element._events[eventName];
    if (!(cache instanceof Array)) throw Error.invalidOperation(Sys.Res.eventHandlerInvalid);
    for (var i = 0, l = cache.length; i < l; i++) { if (cache[i].handler === handler) { browserHandler = cache[i].browserHandler; break; } } if (typeof(browserHandler) !== 'function') throw Error.invalidOperation(Sys.Res.eventHandlerInvalid); if (element.removeEventListener) { element.removeEventListener(eventName, browserHandler, false); } else if (element.detachEvent) { element.detachEvent('on' + eventName, browserHandler); } cache.splice(i, 1); } Sys.UI.DomEvent._ensureDomNode = function Sys$UI$DomEvent$_ensureDomNode(element) { if (element.tagName && (element.tagName.toUpperCase() === "SCRIPT")) return; var doc = element.ownerDocument || element.document || element; if ((typeof(element.document) !== 'object') && (element != doc) && (typeof(element.nodeType) !== 'number')) { throw Error.argument("element", Sys.Res.argumentDomNode); } } Sys.UI.DomElement = function Sys$UI$DomElement() { /// if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.UI.DomElement.registerClass(‘Sys.UI.DomElement’);
    Sys.UI.DomElement.addCssClass = function Sys$UI$DomElement$addCssClass(element, className) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    if (!Sys.UI.DomElement.containsCssClass(element, className)) {
    if (element.className === ”) {
    element.className = className;
    }
    else {
    element.className += ‘ ‘ + className;
    }
    }
    }
    Sys.UI.DomElement.containsCssClass = function Sys$UI$DomElement$containsCssClass(element, className) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    return Array.contains(element.className.split(‘ ‘), className);
    }
    Sys.UI.DomElement.getBounds = function Sys$UI$DomElement$getBounds(element) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    var offset = Sys.UI.DomElement.getLocation(element);
    return new Sys.UI.Bounds(offset.x, offset.y, element.offsetWidth || 0, element.offsetHeight || 0);
    }
    var $get = Sys.UI.DomElement.getElementById = function Sys$UI$DomElement$getElementById(id, element) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “id”, type: String},
    {name: “element”, mayBeNull: true, domElement: true, optional: true}
    ]);
    if (e) throw e;
    if (!element) return document.getElementById(id);
    if (element.getElementById) return element.getElementById(id);
    var nodeQueue = [];
    var childNodes = element.childNodes;
    for (var i = 0; i < childNodes.length; i++) { var node = childNodes[i]; if (node.nodeType == 1) { nodeQueue[nodeQueue.length] = node; } } while (nodeQueue.length) { node = nodeQueue.shift(); if (node.id == id) { return node; } childNodes = node.childNodes; for (i = 0; i < childNodes.length; i++) { node = childNodes[i]; if (node.nodeType == 1) { nodeQueue[nodeQueue.length] = node; } } } return null; } if (document.documentElement.getBoundingClientRect) { Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) { /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    if (element.self || element.nodeType === 9 ||
    (element === document.documentElement) ||
    (element.parentNode === element.ownerDocument.documentElement)) {
    return new Sys.UI.Point(0, 0);
    }

    var clientRect = element.getBoundingClientRect();
    if (!clientRect) {
    return new Sys.UI.Point(0,0);
    }
    var ex, documentElement = element.ownerDocument.documentElement,
    offsetX = Math.round(clientRect.left) + documentElement.scrollLeft,
    offsetY = Math.round(clientRect.top) + documentElement.scrollTop;
    if (Sys.Browser.agent === Sys.Browser.InternetExplorer) {
    try {
    var f = element.ownerDocument.parentWindow.frameElement || null;
    if (f) {
    var offset = (f.frameBorder === “0” || f.frameBorder === “no”) ? 2 : 0;
    offsetX += offset;
    offsetY += offset;
    }
    }
    catch(ex) {
    }
    if (Sys.Browser.version === 7 && !document.documentMode) {
    var body = document.body,
    rect = body.getBoundingClientRect(),
    zoom = (rect.right-rect.left) / body.clientWidth;
    zoom = Math.round(zoom * 100);
    zoom = (zoom – zoom % 5) / 100;
    if (!isNaN(zoom) && (zoom !== 1)) {
    offsetX = Math.round(offsetX / zoom);
    offsetY = Math.round(offsetY / zoom);
    }
    }
    if ((document.documentMode || 0) < 8) { offsetX -= documentElement.clientLeft; offsetY -= documentElement.clientTop; } } return new Sys.UI.Point(offsetX, offsetY); } } else if (Sys.Browser.agent === Sys.Browser.Safari) { Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) { ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    if ((element.window && (element.window === element)) || element.nodeType === 9) return new Sys.UI.Point(0,0);
    var offsetX = 0, offsetY = 0,
    parent,
    previous = null,
    previousStyle = null,
    currentStyle;
    for (parent = element; parent; previous = parent, previousStyle = currentStyle, parent = parent.offsetParent) {
    currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
    var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
    if ((parent.offsetLeft || parent.offsetTop) &&
    ((tagName !== “BODY”) || (!previousStyle || previousStyle.position !== “absolute”))) {
    offsetX += parent.offsetLeft;
    offsetY += parent.offsetTop;
    }
    if (previous && Sys.Browser.version >= 3) {
    offsetX += parseInt(currentStyle.borderLeftWidth);
    offsetY += parseInt(currentStyle.borderTopWidth);
    }
    }
    currentStyle = Sys.UI.DomElement._getCurrentStyle(element);
    var elementPosition = currentStyle ? currentStyle.position : null;
    if (!elementPosition || (elementPosition !== “absolute”)) {
    for (parent = element.parentNode; parent; parent = parent.parentNode) {
    tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
    if ((tagName !== “BODY”) && (tagName !== “HTML”) && (parent.scrollLeft || parent.scrollTop)) {
    offsetX -= (parent.scrollLeft || 0);
    offsetY -= (parent.scrollTop || 0);
    }
    currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
    var parentPosition = currentStyle ? currentStyle.position : null;
    if (parentPosition && (parentPosition === “absolute”)) break;
    }
    }
    return new Sys.UI.Point(offsetX, offsetY);
    }
    }
    else {
    Sys.UI.DomElement.getLocation = function Sys$UI$DomElement$getLocation(element) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    if ((element.window && (element.window === element)) || element.nodeType === 9) return new Sys.UI.Point(0,0);
    var offsetX = 0, offsetY = 0,
    parent,
    previous = null,
    previousStyle = null,
    currentStyle = null;
    for (parent = element; parent; previous = parent, previousStyle = currentStyle, parent = parent.offsetParent) {
    var tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
    currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
    if ((parent.offsetLeft || parent.offsetTop) &&
    !((tagName === “BODY”) &&
    (!previousStyle || previousStyle.position !== “absolute”))) {
    offsetX += parent.offsetLeft;
    offsetY += parent.offsetTop;
    }
    if (previous !== null && currentStyle) {
    if ((tagName !== “TABLE”) && (tagName !== “TD”) && (tagName !== “HTML”)) {
    offsetX += parseInt(currentStyle.borderLeftWidth) || 0;
    offsetY += parseInt(currentStyle.borderTopWidth) || 0;
    }
    if (tagName === “TABLE” &&
    (currentStyle.position === “relative” || currentStyle.position === “absolute”)) {
    offsetX += parseInt(currentStyle.marginLeft) || 0;
    offsetY += parseInt(currentStyle.marginTop) || 0;
    }
    }
    }
    currentStyle = Sys.UI.DomElement._getCurrentStyle(element);
    var elementPosition = currentStyle ? currentStyle.position : null;
    if (!elementPosition || (elementPosition !== “absolute”)) {
    for (parent = element.parentNode; parent; parent = parent.parentNode) {
    tagName = parent.tagName ? parent.tagName.toUpperCase() : null;
    if ((tagName !== “BODY”) && (tagName !== “HTML”) && (parent.scrollLeft || parent.scrollTop)) {
    offsetX -= (parent.scrollLeft || 0);
    offsetY -= (parent.scrollTop || 0);
    currentStyle = Sys.UI.DomElement._getCurrentStyle(parent);
    if (currentStyle) {
    offsetX += parseInt(currentStyle.borderLeftWidth) || 0;
    offsetY += parseInt(currentStyle.borderTopWidth) || 0;
    }
    }
    }
    }
    return new Sys.UI.Point(offsetX, offsetY);
    }
    }
    Sys.UI.DomElement.isDomElement = function Sys$UI$DomElement$isDomElement(obj) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “obj”}
    ]);
    if (e) throw e;
    return Sys._isDomElement(obj);
    }
    Sys.UI.DomElement.removeCssClass = function Sys$UI$DomElement$removeCssClass(element, className) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    var currentClassName = ‘ ‘ + element.className + ‘ ‘;
    var index = currentClassName.indexOf(‘ ‘ + className + ‘ ‘);
    if (index >= 0) {
    element.className = (currentClassName.substr(0, index) + ‘ ‘ +
    currentClassName.substring(index + className.length + 1, currentClassName.length)).trim();
    }
    }
    Sys.UI.DomElement.resolveElement = function Sys$UI$DomElement$resolveElement(elementOrElementId, containerElement) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “elementOrElementId”, mayBeNull: true},
    {name: “containerElement”, mayBeNull: true, domElement: true, optional: true}
    ]);
    if (e) throw e;
    var el = elementOrElementId;
    if (!el) return null;
    if (typeof(el) === “string”) {
    el = Sys.UI.DomElement.getElementById(el, containerElement);
    if (!el) {
    throw Error.argument(“elementOrElementId”, String.format(Sys.Res.elementNotFound, elementOrElementId));
    }
    }
    else if(!Sys.UI.DomElement.isDomElement(el)) {
    throw Error.argument(“elementOrElementId”, Sys.Res.expectedElementOrId);
    }
    return el;
    }
    Sys.UI.DomElement.raiseBubbleEvent = function Sys$UI$DomElement$raiseBubbleEvent(source, args) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “source”, domElement: true},
    {name: “args”, type: Sys.EventArgs}
    ]);
    if (e) throw e;
    var target = source;
    while (target) {
    var control = target.control;
    if (control && control.onBubbleEvent && control.raiseBubbleEvent) {
    Sys.UI.DomElement._raiseBubbleEventFromControl(control, source, args);
    return;
    }
    target = target.parentNode;
    }
    }
    Sys.UI.DomElement._raiseBubbleEventFromControl = function Sys$UI$DomElement$_raiseBubbleEventFromControl(control, source, args) {
    if (!control.onBubbleEvent(source, args)) {
    control._raiseBubbleEvent(source, args);
    }
    }
    Sys.UI.DomElement.setLocation = function Sys$UI$DomElement$setLocation(element, x, y) {
    ///

    /// /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “x”, type: Number, integer: true},
    {name: “y”, type: Number, integer: true}
    ]);
    if (e) throw e;
    var style = element.style;
    style.position = ‘absolute’;
    style.left = x + “px”;
    style.top = y + “px”;
    }
    Sys.UI.DomElement.toggleCssClass = function Sys$UI$DomElement$toggleCssClass(element, className) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    if (Sys.UI.DomElement.containsCssClass(element, className)) {
    Sys.UI.DomElement.removeCssClass(element, className);
    }
    else {
    Sys.UI.DomElement.addCssClass(element, className);
    }
    }
    Sys.UI.DomElement.getVisibilityMode = function Sys$UI$DomElement$getVisibilityMode(element) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    return (element._visibilityMode === Sys.UI.VisibilityMode.hide) ?
    Sys.UI.VisibilityMode.hide :
    Sys.UI.VisibilityMode.collapse;
    }
    Sys.UI.DomElement.setVisibilityMode = function Sys$UI$DomElement$setVisibilityMode(element, value) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “value”, type: Sys.UI.VisibilityMode}
    ]);
    if (e) throw e;
    Sys.UI.DomElement._ensureOldDisplayMode(element);
    if (element._visibilityMode !== value) {
    element._visibilityMode = value;
    if (Sys.UI.DomElement.getVisible(element) === false) {
    if (element._visibilityMode === Sys.UI.VisibilityMode.hide) {
    element.style.display = element._oldDisplayMode;
    }
    else {
    element.style.display = ‘none’;
    }
    }
    element._visibilityMode = value;
    }
    }
    Sys.UI.DomElement.getVisible = function Sys$UI$DomElement$getVisible(element) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);
    if (!style) return true;
    return (style.visibility !== ‘hidden’) && (style.display !== ‘none’);
    }
    Sys.UI.DomElement.setVisible = function Sys$UI$DomElement$setVisible(element, value) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “value”, type: Boolean}
    ]);
    if (e) throw e;
    if (value !== Sys.UI.DomElement.getVisible(element)) {
    Sys.UI.DomElement._ensureOldDisplayMode(element);
    element.style.visibility = value ? ‘visible’ : ‘hidden’;
    if (value || (element._visibilityMode === Sys.UI.VisibilityMode.hide)) {
    element.style.display = element._oldDisplayMode;
    }
    else {
    element.style.display = ‘none’;
    }
    }
    }
    Sys.UI.DomElement._ensureOldDisplayMode = function Sys$UI$DomElement$_ensureOldDisplayMode(element) {
    if (!element._oldDisplayMode) {
    var style = element.currentStyle || Sys.UI.DomElement._getCurrentStyle(element);
    element._oldDisplayMode = style ? style.display : null;
    if (!element._oldDisplayMode || element._oldDisplayMode === ‘none’) {
    switch(element.tagName.toUpperCase()) {
    case ‘DIV’: case ‘P’: case ‘ADDRESS’: case ‘BLOCKQUOTE’: case ‘BODY’: case ‘COL’:
    case ‘COLGROUP’: case ‘DD’: case ‘DL’: case ‘DT’: case ‘FIELDSET’: case ‘FORM’:
    case ‘H1’: case ‘H2’: case ‘H3’: case ‘H4’: case ‘H5’: case ‘H6’: case ‘HR’:
    case ‘IFRAME’: case ‘LEGEND’: case ‘OL’: case ‘PRE’: case ‘TABLE’: case ‘TD’:
    case ‘TH’: case ‘TR’: case ‘UL’:
    element._oldDisplayMode = ‘block’;
    break;
    case ‘LI’:
    element._oldDisplayMode = ‘list-item’;
    break;
    default:
    element._oldDisplayMode = ‘inline’;
    }
    }
    }
    }
    Sys.UI.DomElement._getWindow = function Sys$UI$DomElement$_getWindow(element) {
    var doc = element.ownerDocument || element.document || element;
    return doc.defaultView || doc.parentWindow;
    }
    Sys.UI.DomElement._getCurrentStyle = function Sys$UI$DomElement$_getCurrentStyle(element) {
    if (element.nodeType === 3) return null;
    var w = Sys.UI.DomElement._getWindow(element);
    if (element.documentElement) element = element.documentElement;
    var computedStyle = (w && (element !== w) && w.getComputedStyle) ?
    w.getComputedStyle(element, null) :
    element.currentStyle || element.style;
    if (!computedStyle && (Sys.Browser.agent === Sys.Browser.Safari) && element.style) {
    var oldDisplay = element.style.display;
    var oldPosition = element.style.position;
    element.style.position = ‘absolute’;
    element.style.display = ‘block’;
    var style = w.getComputedStyle(element, null);
    element.style.display = oldDisplay;
    element.style.position = oldPosition;
    computedStyle = {};
    for (var n in style) {
    computedStyle[n] = style[n];
    }
    computedStyle.display = ‘none’;
    }
    return computedStyle;
    }

    Sys.IContainer = function Sys$IContainer() {
    throw Error.notImplemented();
    }
    function Sys$IContainer$addComponent(component) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “component”, type: Sys.Component}
    ]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$IContainer$removeComponent(component) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “component”, type: Sys.Component}
    ]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$IContainer$findComponent(id) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “id”, type: String}
    ]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$IContainer$getComponents() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.IContainer.prototype = {
    addComponent: Sys$IContainer$addComponent,
    removeComponent: Sys$IContainer$removeComponent,
    findComponent: Sys$IContainer$findComponent,
    getComponents: Sys$IContainer$getComponents
    }
    Sys.IContainer.registerInterface(“Sys.IContainer”);

    Sys.ApplicationLoadEventArgs = function Sys$ApplicationLoadEventArgs(components, isPartialLoad) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “components”, type: Array, elementType: Sys.Component},
    {name: “isPartialLoad”, type: Boolean}
    ]);
    if (e) throw e;
    Sys.ApplicationLoadEventArgs.initializeBase(this);
    this._components = components;
    this._isPartialLoad = isPartialLoad;
    }

    function Sys$ApplicationLoadEventArgs$get_components() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._components;
    }
    function Sys$ApplicationLoadEventArgs$get_isPartialLoad() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._isPartialLoad;
    }
    Sys.ApplicationLoadEventArgs.prototype = {
    get_components: Sys$ApplicationLoadEventArgs$get_components,
    get_isPartialLoad: Sys$ApplicationLoadEventArgs$get_isPartialLoad
    }
    Sys.ApplicationLoadEventArgs.registerClass(‘Sys.ApplicationLoadEventArgs’, Sys.EventArgs);

    Sys._Application = function Sys$_Application() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    Sys._Application.initializeBase(this);
    this._disposableObjects = [];
    this._components = {};
    this._createdComponents = [];
    this._secondPassComponents = [];
    this._unloadHandlerDelegate = Function.createDelegate(this, this._unloadHandler);
    Sys.UI.DomEvent.addHandler(window, “unload”, this._unloadHandlerDelegate);
    this._domReady();
    }
    function Sys$_Application$get_isCreatingComponents() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._creatingComponents;
    }
    function Sys$_Application$get_isDisposing() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._disposing;
    }
    function Sys$_Application$add_init(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    if (this._initialized) {
    handler(this, Sys.EventArgs.Empty);
    }
    else {
    this.get_events().addHandler(“init”, handler);
    }
    }
    function Sys$_Application$remove_init(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().removeHandler(“init”, handler);
    }
    function Sys$_Application$add_load(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().addHandler(“load”, handler);
    }
    function Sys$_Application$remove_load(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().removeHandler(“load”, handler);
    }
    function Sys$_Application$add_unload(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().addHandler(“unload”, handler);
    }
    function Sys$_Application$remove_unload(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this.get_events().removeHandler(“unload”, handler);
    }
    function Sys$_Application$addComponent(component) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “component”, type: Sys.Component}
    ]);
    if (e) throw e;
    var id = component.get_id();
    if (!id) throw Error.invalidOperation(Sys.Res.cantAddWithoutId);
    if (typeof(this._components[id]) !== ‘undefined’) throw Error.invalidOperation(String.format(Sys.Res.appDuplicateComponent, id));
    this._components[id] = component;
    }
    function Sys$_Application$beginCreateComponents() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._creatingComponents = true;
    }
    function Sys$_Application$dispose() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._disposing) {
    this._disposing = true;
    if (this._timerCookie) {
    window.clearTimeout(this._timerCookie);
    delete this._timerCookie;
    }
    if (this._endRequestHandler) {
    Sys.WebForms.PageRequestManager.getInstance().remove_endRequest(this._endRequestHandler);
    delete this._endRequestHandler;
    }
    if (this._beginRequestHandler) {
    Sys.WebForms.PageRequestManager.getInstance().remove_beginRequest(this._beginRequestHandler);
    delete this._beginRequestHandler;
    }
    if (window.pageUnload) {
    window.pageUnload(this, Sys.EventArgs.Empty);
    }
    var unloadHandler = this.get_events().getHandler(“unload”);
    if (unloadHandler) {
    unloadHandler(this, Sys.EventArgs.Empty);
    }
    var disposableObjects = Array.clone(this._disposableObjects);
    for (var i = 0, l = disposableObjects.length; i < l; i++) { var object = disposableObjects[i]; if (typeof(object) !== "undefined") { object.dispose(); } } Array.clear(this._disposableObjects); Sys.UI.DomEvent.removeHandler(window, "unload", this._unloadHandlerDelegate); if (Sys._ScriptLoader) { var sl = Sys._ScriptLoader.getInstance(); if(sl) { sl.dispose(); } } Sys._Application.callBaseMethod(this, 'dispose'); } } function Sys$_Application$disposeElement(element, childNodesOnly) { /// /// /// var e = Function._validateParams(arguments, [
    {name: “element”},
    {name: “childNodesOnly”, type: Boolean}
    ]);
    if (e) throw e;
    if (element.nodeType === 1) {
    var i, allElements = element.getElementsByTagName(“*”),
    length = allElements.length,
    children = new Array(length);
    for (i = 0; i < length; i++) { children[i] = allElements[i]; } for (i = length - 1; i >= 0; i–) {
    var child = children[i];
    var d = child.dispose;
    if (d && typeof(d) === “function”) {
    child.dispose();
    }
    else {
    var c = child.control;
    if (c && typeof(c.dispose) === “function”) {
    c.dispose();
    }
    }
    var list = child._behaviors;
    if (list) {
    this._disposeComponents(list);
    }
    list = child._components;
    if (list) {
    this._disposeComponents(list);
    child._components = null;
    }
    }
    if (!childNodesOnly) {
    var d = element.dispose;
    if (d && typeof(d) === “function”) {
    element.dispose();
    }
    else {
    var c = element.control;
    if (c && typeof(c.dispose) === “function”) {
    c.dispose();
    }
    }
    var list = element._behaviors;
    if (list) {
    this._disposeComponents(list);
    }
    list = element._components;
    if (list) {
    this._disposeComponents(list);
    element._components = null;
    }
    }
    }
    }
    function Sys$_Application$endCreateComponents() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    var components = this._secondPassComponents;
    for (var i = 0, l = components.length; i < l; i++) { var component = components[i].component; Sys$Component$_setReferences(component, components[i].references); component.endUpdate(); } this._secondPassComponents = []; this._creatingComponents = false; } function Sys$_Application$findComponent(id, parent) { /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “id”, type: String},
    {name: “parent”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    return (parent ?
    ((Sys.IContainer.isInstanceOfType(parent)) ?
    parent.findComponent(id) :
    parent[id] || null) :
    Sys.Application._components[id] || null);
    }
    function Sys$_Application$getComponents() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    var res = [];
    var components = this._components;
    for (var name in components) {
    res[res.length] = components[name];
    }
    return res;
    }
    function Sys$_Application$initialize() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if(!this.get_isInitialized() && !this._disposing) {
    Sys._Application.callBaseMethod(this, ‘initialize’);
    this._raiseInit();
    if (this.get_stateString) {
    if (Sys.WebForms && Sys.WebForms.PageRequestManager) {
    this._beginRequestHandler = Function.createDelegate(this, this._onPageRequestManagerBeginRequest);
    Sys.WebForms.PageRequestManager.getInstance().add_beginRequest(this._beginRequestHandler);
    this._endRequestHandler = Function.createDelegate(this, this._onPageRequestManagerEndRequest);
    Sys.WebForms.PageRequestManager.getInstance().add_endRequest(this._endRequestHandler);
    }
    var loadedEntry = this.get_stateString();
    if (loadedEntry !== this._currentEntry) {
    this._navigate(loadedEntry);
    }
    else {
    this._ensureHistory();
    }
    }
    this.raiseLoad();
    }
    }
    function Sys$_Application$notifyScriptLoaded() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    }
    function Sys$_Application$registerDisposableObject(object) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “object”, type: Sys.IDisposable}
    ]);
    if (e) throw e;
    if (!this._disposing) {
    var objects = this._disposableObjects,
    i = objects.length;
    objects[i] = object;
    object.__msdisposeindex = i;
    }
    }
    function Sys$_Application$raiseLoad() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    var h = this.get_events().getHandler(“load”);
    var args = new Sys.ApplicationLoadEventArgs(Array.clone(this._createdComponents), !!this._loaded);
    this._loaded = true;
    if (h) {
    h(this, args);
    }
    if (window.pageLoad) {
    window.pageLoad(this, args);
    }
    this._createdComponents = [];
    }
    function Sys$_Application$removeComponent(component) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “component”, type: Sys.Component}
    ]);
    if (e) throw e;
    var id = component.get_id();
    if (id) delete this._components[id];
    }
    function Sys$_Application$unregisterDisposableObject(object) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “object”, type: Sys.IDisposable}
    ]);
    if (e) throw e;
    if (!this._disposing) {
    var i = object.__msdisposeindex;
    if (typeof(i) === “number”) {
    var disposableObjects = this._disposableObjects;
    delete disposableObjects[i];
    delete object.__msdisposeindex;
    if (++this._deleteCount > 1000) {
    var newArray = [];
    for (var j = 0, l = disposableObjects.length; j < l; j++) { object = disposableObjects[j]; if (typeof(object) !== "undefined") { object.__msdisposeindex = newArray.length; newArray.push(object); } } this._disposableObjects = newArray; this._deleteCount = 0; } } } } function Sys$_Application$_addComponentToSecondPass(component, references) { this._secondPassComponents[this._secondPassComponents.length] = {component: component, references: references}; } function Sys$_Application$_disposeComponents(list) { if (list) { for (var i = list.length - 1; i >= 0; i–) {
    var item = list[i];
    if (typeof(item.dispose) === “function”) {
    item.dispose();
    }
    }
    }
    }
    function Sys$_Application$_domReady() {
    var check, er, app = this;
    function init() { app.initialize(); }
    var onload = function() {
    Sys.UI.DomEvent.removeHandler(window, “load”, onload);
    init();
    }
    Sys.UI.DomEvent.addHandler(window, “load”, onload);

    if (document.addEventListener) {
    try {
    document.addEventListener(“DOMContentLoaded”, check = function() {
    document.removeEventListener(“DOMContentLoaded”, check, false);
    init();
    }, false);
    }
    catch (er) { }
    }
    else if (document.attachEvent) {
    if ((window == window.top) && document.documentElement.doScroll) {
    var timeout, el = document.createElement(“div”);
    check = function() {
    try {
    el.doScroll(“left”);
    }
    catch (er) {
    timeout = window.setTimeout(check, 0);
    return;
    }
    el = null;
    init();
    }
    check();
    }
    else {
    document.attachEvent(“onreadystatechange”, check = function() {
    if (document.readyState === “complete”) {
    document.detachEvent(“onreadystatechange”, check);
    init();
    }
    });
    }
    }
    }
    function Sys$_Application$_raiseInit() {
    var handler = this.get_events().getHandler(“init”);
    if (handler) {
    this.beginCreateComponents();
    handler(this, Sys.EventArgs.Empty);
    this.endCreateComponents();
    }
    }
    function Sys$_Application$_unloadHandler(event) {
    this.dispose();
    }
    Sys._Application.prototype = {
    _creatingComponents: false,
    _disposing: false,
    _deleteCount: 0,
    get_isCreatingComponents: Sys$_Application$get_isCreatingComponents,
    get_isDisposing: Sys$_Application$get_isDisposing,
    add_init: Sys$_Application$add_init,
    remove_init: Sys$_Application$remove_init,
    add_load: Sys$_Application$add_load,
    remove_load: Sys$_Application$remove_load,
    add_unload: Sys$_Application$add_unload,
    remove_unload: Sys$_Application$remove_unload,
    addComponent: Sys$_Application$addComponent,
    beginCreateComponents: Sys$_Application$beginCreateComponents,
    dispose: Sys$_Application$dispose,
    disposeElement: Sys$_Application$disposeElement,
    endCreateComponents: Sys$_Application$endCreateComponents,
    findComponent: Sys$_Application$findComponent,
    getComponents: Sys$_Application$getComponents,
    initialize: Sys$_Application$initialize,
    notifyScriptLoaded: Sys$_Application$notifyScriptLoaded,
    registerDisposableObject: Sys$_Application$registerDisposableObject,
    raiseLoad: Sys$_Application$raiseLoad,
    removeComponent: Sys$_Application$removeComponent,
    unregisterDisposableObject: Sys$_Application$unregisterDisposableObject,
    _addComponentToSecondPass: Sys$_Application$_addComponentToSecondPass,
    _disposeComponents: Sys$_Application$_disposeComponents,
    _domReady: Sys$_Application$_domReady,
    _raiseInit: Sys$_Application$_raiseInit,
    _unloadHandler: Sys$_Application$_unloadHandler
    }
    Sys._Application.registerClass(‘Sys._Application’, Sys.Component, Sys.IContainer);
    Sys.Application = new Sys._Application();
    var $find = Sys.Application.findComponent;

    Sys.UI.Behavior = function Sys$UI$Behavior(element) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    Sys.UI.Behavior.initializeBase(this);
    this._element = element;
    var behaviors = element._behaviors;
    if (!behaviors) {
    element._behaviors = [this];
    }
    else {
    behaviors[behaviors.length] = this;
    }
    }
    function Sys$UI$Behavior$get_element() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._element;
    }
    function Sys$UI$Behavior$get_id() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    var baseId = Sys.UI.Behavior.callBaseMethod(this, ‘get_id’);
    if (baseId) return baseId;
    if (!this._element || !this._element.id) return ”;
    return this._element.id + ‘$’ + this.get_name();
    }
    function Sys$UI$Behavior$get_name() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._name) return this._name;
    var name = Object.getTypeName(this);
    var i = name.lastIndexOf(‘.’);
    if (i !== -1) name = name.substr(i + 1);
    if (!this.get_isInitialized()) this._name = name;
    return name;
    }
    function Sys$UI$Behavior$set_name(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    if ((value === ”) || (value.charAt(0) === ‘ ‘) || (value.charAt(value.length – 1) === ‘ ‘))
    throw Error.argument(‘value’, Sys.Res.invalidId);
    if (typeof(this._element[value]) !== ‘undefined’)
    throw Error.invalidOperation(String.format(Sys.Res.behaviorDuplicateName, value));
    if (this.get_isInitialized()) throw Error.invalidOperation(Sys.Res.cantSetNameAfterInit);
    this._name = value;
    }
    function Sys$UI$Behavior$initialize() {
    Sys.UI.Behavior.callBaseMethod(this, ‘initialize’);
    var name = this.get_name();
    if (name) this._element[name] = this;
    }
    function Sys$UI$Behavior$dispose() {
    Sys.UI.Behavior.callBaseMethod(this, ‘dispose’);
    var e = this._element;
    if (e) {
    var name = this.get_name();
    if (name) {
    e[name] = null;
    }
    var behaviors = e._behaviors;
    Array.remove(behaviors, this);
    if (behaviors.length === 0) {
    e._behaviors = null;
    }
    delete this._element;
    }
    }
    Sys.UI.Behavior.prototype = {
    _name: null,
    get_element: Sys$UI$Behavior$get_element,
    get_id: Sys$UI$Behavior$get_id,
    get_name: Sys$UI$Behavior$get_name,
    set_name: Sys$UI$Behavior$set_name,
    initialize: Sys$UI$Behavior$initialize,
    dispose: Sys$UI$Behavior$dispose
    }
    Sys.UI.Behavior.registerClass(‘Sys.UI.Behavior’, Sys.Component);
    Sys.UI.Behavior.getBehaviorByName = function Sys$UI$Behavior$getBehaviorByName(element, name) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “name”, type: String}
    ]);
    if (e) throw e;
    var b = element[name];
    return (b && Sys.UI.Behavior.isInstanceOfType(b)) ? b : null;
    }
    Sys.UI.Behavior.getBehaviors = function Sys$UI$Behavior$getBehaviors(element) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    if (!element._behaviors) return [];
    return Array.clone(element._behaviors);
    }
    Sys.UI.Behavior.getBehaviorsByType = function Sys$UI$Behavior$getBehaviorsByType(element, type) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true},
    {name: “type”, type: Type}
    ]);
    if (e) throw e;
    var behaviors = element._behaviors;
    var results = [];
    if (behaviors) {
    for (var i = 0, l = behaviors.length; i < l; i++) { if (type.isInstanceOfType(behaviors[i])) { results[results.length] = behaviors[i]; } } } return results; } Sys.UI.VisibilityMode = function Sys$UI$VisibilityMode() { /// ///
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.UI.VisibilityMode.prototype = {
    hide: 0,
    collapse: 1
    }
    Sys.UI.VisibilityMode.registerEnum(“Sys.UI.VisibilityMode”);

    Sys.UI.Control = function Sys$UI$Control(element) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “element”, domElement: true}
    ]);
    if (e) throw e;
    if (typeof(element.control) !== ‘undefined’) throw Error.invalidOperation(Sys.Res.controlAlreadyDefined);
    Sys.UI.Control.initializeBase(this);
    this._element = element;
    element.control = this;
    var role = this.get_role();
    if (role) {
    element.setAttribute(“role”, role);
    }
    }
    function Sys$UI$Control$get_element() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._element;
    }
    function Sys$UI$Control$get_id() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._element) return ”;
    return this._element.id;
    }
    function Sys$UI$Control$set_id(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    throw Error.invalidOperation(Sys.Res.cantSetId);
    }
    function Sys$UI$Control$get_parent() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._parent) return this._parent;
    if (!this._element) return null;

    var parentElement = this._element.parentNode;
    while (parentElement) {
    if (parentElement.control) {
    return parentElement.control;
    }
    parentElement = parentElement.parentNode;
    }
    return null;
    }
    function Sys$UI$Control$set_parent(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Sys.UI.Control}]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    var parents = [this];
    var current = value;
    while (current) {
    if (Array.contains(parents, current)) throw Error.invalidOperation(Sys.Res.circularParentChain);
    parents[parents.length] = current;
    current = current.get_parent();
    }
    this._parent = value;
    }
    function Sys$UI$Control$get_role() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return null;
    }
    function Sys$UI$Control$get_visibilityMode() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    return Sys.UI.DomElement.getVisibilityMode(this._element);
    }
    function Sys$UI$Control$set_visibilityMode(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Sys.UI.VisibilityMode}]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    Sys.UI.DomElement.setVisibilityMode(this._element, value);
    }
    function Sys$UI$Control$get_visible() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    return Sys.UI.DomElement.getVisible(this._element);
    }
    function Sys$UI$Control$set_visible(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Boolean}]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    Sys.UI.DomElement.setVisible(this._element, value)
    }
    function Sys$UI$Control$addCssClass(className) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    Sys.UI.DomElement.addCssClass(this._element, className);
    }
    function Sys$UI$Control$dispose() {
    Sys.UI.Control.callBaseMethod(this, ‘dispose’);
    if (this._element) {
    this._element.control = null;
    delete this._element;
    }
    if (this._parent) delete this._parent;
    }
    function Sys$UI$Control$onBubbleEvent(source, args) {
    ///

    /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “source”},
    {name: “args”, type: Sys.EventArgs}
    ]);
    if (e) throw e;
    return false;
    }
    function Sys$UI$Control$raiseBubbleEvent(source, args) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “source”},
    {name: “args”, type: Sys.EventArgs}
    ]);
    if (e) throw e;
    this._raiseBubbleEvent(source, args);
    }
    function Sys$UI$Control$_raiseBubbleEvent(source, args) {
    var currentTarget = this.get_parent();
    while (currentTarget) {
    if (currentTarget.onBubbleEvent(source, args)) {
    return;
    }
    currentTarget = currentTarget.get_parent();
    }
    }
    function Sys$UI$Control$removeCssClass(className) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    Sys.UI.DomElement.removeCssClass(this._element, className);
    }
    function Sys$UI$Control$toggleCssClass(className) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “className”, type: String}
    ]);
    if (e) throw e;
    if (!this._element) throw Error.invalidOperation(Sys.Res.cantBeCalledAfterDispose);
    Sys.UI.DomElement.toggleCssClass(this._element, className);
    }
    Sys.UI.Control.prototype = {
    _parent: null,
    _visibilityMode: Sys.UI.VisibilityMode.hide,
    get_element: Sys$UI$Control$get_element,
    get_id: Sys$UI$Control$get_id,
    set_id: Sys$UI$Control$set_id,
    get_parent: Sys$UI$Control$get_parent,
    set_parent: Sys$UI$Control$set_parent,
    get_role: Sys$UI$Control$get_role,
    get_visibilityMode: Sys$UI$Control$get_visibilityMode,
    set_visibilityMode: Sys$UI$Control$set_visibilityMode,
    get_visible: Sys$UI$Control$get_visible,
    set_visible: Sys$UI$Control$set_visible,
    addCssClass: Sys$UI$Control$addCssClass,
    dispose: Sys$UI$Control$dispose,
    onBubbleEvent: Sys$UI$Control$onBubbleEvent,
    raiseBubbleEvent: Sys$UI$Control$raiseBubbleEvent,
    _raiseBubbleEvent: Sys$UI$Control$_raiseBubbleEvent,
    removeCssClass: Sys$UI$Control$removeCssClass,
    toggleCssClass: Sys$UI$Control$toggleCssClass
    }
    Sys.UI.Control.registerClass(‘Sys.UI.Control’, Sys.Component);
    Sys.HistoryEventArgs = function Sys$HistoryEventArgs(state) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “state”, type: Object}
    ]);
    if (e) throw e;
    Sys.HistoryEventArgs.initializeBase(this);
    this._state = state;
    }
    function Sys$HistoryEventArgs$get_state() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._state;
    }
    Sys.HistoryEventArgs.prototype = {
    get_state: Sys$HistoryEventArgs$get_state
    }
    Sys.HistoryEventArgs.registerClass(‘Sys.HistoryEventArgs’, Sys.EventArgs);
    Sys.Application._appLoadHandler = null;
    Sys.Application._beginRequestHandler = null;
    Sys.Application._clientId = null;
    Sys.Application._currentEntry = ”;
    Sys.Application._endRequestHandler = null;
    Sys.Application._history = null;
    Sys.Application._enableHistory = false;
    Sys.Application._historyEnabledInScriptManager = false;
    Sys.Application._historyFrame = null;
    Sys.Application._historyInitialized = false;
    Sys.Application._historyPointIsNew = false;
    Sys.Application._ignoreTimer = false;
    Sys.Application._initialState = null;
    Sys.Application._state = {};
    Sys.Application._timerCookie = 0;
    Sys.Application._timerHandler = null;
    Sys.Application._uniqueId = null;
    Sys._Application.prototype.get_stateString = function Sys$_Application$get_stateString() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    var hash = null;

    if (Sys.Browser.agent === Sys.Browser.Firefox) {
    var href = window.location.href;
    var hashIndex = href.indexOf(‘#’);
    if (hashIndex !== -1) {
    hash = href.substring(hashIndex + 1);
    }
    else {
    hash = “”;
    }
    return hash;
    }
    else {
    hash = window.location.hash;
    }

    if ((hash.length > 0) && (hash.charAt(0) === ‘#’)) {
    hash = hash.substring(1);
    }
    return hash;
    };
    Sys._Application.prototype.get_enableHistory = function Sys$_Application$get_enableHistory() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    return this._enableHistory;
    };
    Sys._Application.prototype.set_enableHistory = function Sys$_Application$set_enableHistory(value) {
    if (this._initialized && !this._initializing) {
    throw Error.invalidOperation(Sys.Res.historyCannotEnableHistory);
    }
    else if (this._historyEnabledInScriptManager && !value) {
    throw Error.invalidOperation(Sys.Res.invalidHistorySettingCombination);
    }
    this._enableHistory = value;
    };
    Sys._Application.prototype.add_navigate = function Sys$_Application$add_navigate(handler) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    this.get_events().addHandler(“navigate”, handler);
    };
    Sys._Application.prototype.remove_navigate = function Sys$_Application$remove_navigate(handler) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “handler”, type: Function}
    ]);
    if (e) throw e;
    this.get_events().removeHandler(“navigate”, handler);
    };
    Sys._Application.prototype.addHistoryPoint = function Sys$_Application$addHistoryPoint(state, title) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “state”, type: Object},
    {name: “title”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    if (!this._enableHistory) throw Error.invalidOperation(Sys.Res.historyCannotAddHistoryPointWithHistoryDisabled);
    for (var n in state) {
    var v = state[n];
    var t = typeof(v);
    if ((v !== null) && ((t === ‘object’) || (t === ‘function’) || (t === ‘undefined’))) {
    throw Error.argument(‘state’, Sys.Res.stateMustBeStringDictionary);
    }
    }
    this._ensureHistory();
    var initialState = this._state;
    for (var key in state) {
    var value = state" + (title || document.title) + ";
    if (value === null) {
    if (typeof(initialState" + (title || document.title) + ") !== ‘undefined’) {
    delete initialState" + (title || document.title) + ";
    }
    }
    else {
    initialState" + (title || document.title) + " = value;
    }
    }
    var entry = this._serializeState(initialState);
    this._historyPointIsNew = true;
    this._setState(entry, title);
    this._raiseNavigate();
    };
    Sys._Application.prototype.setServerId = function Sys$_Application$setServerId(clientId, uniqueId) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “clientId”, type: String},
    {name: “uniqueId”, type: String}
    ]);
    if (e) throw e;
    this._clientId = clientId;
    this._uniqueId = uniqueId;
    };
    Sys._Application.prototype.setServerState = function Sys$_Application$setServerState(value) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “value”, type: String}
    ]);
    if (e) throw e;
    this._ensureHistory();
    this._state.__s = value;
    this._updateHiddenField(value);
    };
    Sys._Application.prototype._deserializeState = function Sys$_Application$_deserializeState(entry) {
    var result = {};
    entry = entry || ”;
    var serverSeparator = entry.indexOf(‘&&’);
    if ((serverSeparator !== -1) && (serverSeparator + 2 < entry.length)) { result.__s = entry.substr(serverSeparator + 2); entry = entry.substr(0, serverSeparator); } var tokens = entry.split('&'); for (var i = 0, l = tokens.length; i < l; i++) { var token = tokens[i]; var equal = token.indexOf('='); if ((equal !== -1) && (equal + 1 < token.length)) { var name = token.substr(0, equal); var value = token.substr(equal + 1); result[name] = decodeURIComponent(value); } } return result; }; Sys._Application.prototype._enableHistoryInScriptManager = function Sys$_Application$_enableHistoryInScriptManager() { this._enableHistory = true; this._historyEnabledInScriptManager = true; }; Sys._Application.prototype._ensureHistory = function Sys$_Application$_ensureHistory() { if (!this._historyInitialized && this._enableHistory) { if ((Sys.Browser.agent === Sys.Browser.InternetExplorer) && (Sys.Browser.documentMode < 8)) { this._historyFrame = document.getElementById('__historyFrame'); if (!this._historyFrame) throw Error.invalidOperation(Sys.Res.historyMissingFrame); this._ignoreIFrame = true; } this._timerHandler = Function.createDelegate(this, this._onIdle); this._timerCookie = window.setTimeout(this._timerHandler, 100); try { this._initialState = this._deserializeState(this.get_stateString()); } catch(e) {} this._historyInitialized = true; } }; Sys._Application.prototype._navigate = function Sys$_Application$_navigate(entry) { this._ensureHistory(); var state = this._deserializeState(entry); if (this._uniqueId) { var oldServerEntry = this._state.__s || ''; var newServerEntry = state.__s || ''; if (newServerEntry !== oldServerEntry) { this._updateHiddenField(newServerEntry); __doPostBack(this._uniqueId, newServerEntry); this._state = state; return; } } this._setState(entry); this._state = state; this._raiseNavigate(); }; Sys._Application.prototype._onIdle = function Sys$_Application$_onIdle() { delete this._timerCookie; var entry = this.get_stateString(); if (entry !== this._currentEntry) { if (!this._ignoreTimer) { this._historyPointIsNew = false; this._navigate(entry); } } else { this._ignoreTimer = false; } this._timerCookie = window.setTimeout(this._timerHandler, 100); }; Sys._Application.prototype._onIFrameLoad = function Sys$_Application$_onIFrameLoad(entry) { this._ensureHistory(); if (!this._ignoreIFrame) { this._historyPointIsNew = false; this._navigate(entry); } this._ignoreIFrame = false; }; Sys._Application.prototype._onPageRequestManagerBeginRequest = function Sys$_Application$_onPageRequestManagerBeginRequest(sender, args) { this._ignoreTimer = true; this._originalTitle = document.title; }; Sys._Application.prototype._onPageRequestManagerEndRequest = function Sys$_Application$_onPageRequestManagerEndRequest(sender, args) { var dataItem = args.get_dataItems()[this._clientId]; var originalTitle = this._originalTitle; this._originalTitle = null; var eventTarget = document.getElementById("__EVENTTARGET"); if (eventTarget && eventTarget.value === this._uniqueId) { eventTarget.value = ''; } if (typeof(dataItem) !== 'undefined') { this.setServerState(dataItem); this._historyPointIsNew = true; } else { this._ignoreTimer = false; } var entry = this._serializeState(this._state); if (entry !== this._currentEntry) { this._ignoreTimer = true; if (typeof(originalTitle) === "string") { if (Sys.Browser.agent !== Sys.Browser.InternetExplorer || Sys.Browser.version > 7) {
    var newTitle = document.title;
    document.title = originalTitle;
    this._setState(entry);
    document.title = newTitle;
    }
    else {
    this._setState(entry);
    }
    this._raiseNavigate();
    }
    else {
    this._setState(entry);
    this._raiseNavigate();
    }
    }
    };
    Sys._Application.prototype._raiseNavigate = function Sys$_Application$_raiseNavigate() {
    var isNew = this._historyPointIsNew;
    var h = this.get_events().getHandler(“navigate”);
    var stateClone = {};
    for (var key in this._state) {
    if (key !== ‘__s’) {
    stateClone" + (title || document.title) + " = this._state" + (title || document.title) + ";
    }
    }
    var args = new Sys.HistoryEventArgs(stateClone);
    if (h) {
    h(this, args);
    }
    if (!isNew) {
    var err;
    try {
    if ((Sys.Browser.agent === Sys.Browser.Firefox) && window.location.hash &&
    (!window.frameElement || window.top.location.hash)) {
    (Sys.Browser.version < 3.5) ? window.history.go(0) : location.hash = this.get_stateString(); } } catch(err) { } } }; Sys._Application.prototype._serializeState = function Sys$_Application$_serializeState(state) { var serialized = []; for (var key in state) { var value = state" + (title || document.title) + "; if (key === '__s') { var serverState = value; } else { if (key.indexOf('=') !== -1) throw Error.argument('state', Sys.Res.stateFieldNameInvalid); serialized[serialized.length] = key + '=' + encodeURIComponent(value); } } return serialized.join('&') + (serverState ? '&&' + serverState : ''); }; Sys._Application.prototype._setState = function Sys$_Application$_setState(entry, title) { if (this._enableHistory) { entry = entry || ''; if (entry !== this._currentEntry) { if (window.theForm) { var action = window.theForm.action; var hashIndex = action.indexOf('#'); window.theForm.action = ((hashIndex !== -1) ? action.substring(0, hashIndex) : action) + '#' + entry; } if (this._historyFrame && this._historyPointIsNew) { this._ignoreIFrame = true; var frameDoc = this._historyFrame.contentWindow.document; frameDoc.open("javascript:'‘”);
    frameDoc.write(“parent.Sys.Application._onIFrameLoad(” +
    Sys.Serialization.JavaScriptSerializer.serialize(entry) +
    “);
    “>”);
    frameDoc.close();
    }
    this._ignoreTimer = false;
    this._currentEntry = entry;
    if (this._historyFrame || this._historyPointIsNew) {
    var currentHash = this.get_stateString();
    if (entry !== currentHash) {
    var loc = document.location;
    if (loc.href.length – loc.hash.length + entry.length > 2048) {
    throw Error.invalidOperation(String.format(Sys.Res.urlTooLong, 2048));
    }
    window.location.hash = entry;
    this._currentEntry = this.get_stateString();
    if ((typeof(title) !== ‘undefined’) && (title !== null)) {
    document.title = title;
    }
    }
    }
    this._historyPointIsNew = false;
    }
    }
    };
    Sys._Application.prototype._updateHiddenField = function Sys$_Application$_updateHiddenField(value) {
    if (this._clientId) {
    var serverStateField = document.getElementById(this._clientId);
    if (serverStateField) {
    serverStateField.value = value;
    }
    }
    };

    if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function window$XMLHttpRequest() {
    var progIDs = [ ‘Msxml2.XMLHTTP.3.0’, ‘Msxml2.XMLHTTP’ ];
    for (var i = 0, l = progIDs.length; i < l; i++) { try { return new ActiveXObject(progIDs[i]); } catch (ex) { } } return null; } } Type.registerNamespace('Sys.Net'); Sys.Net.WebRequestExecutor = function Sys$Net$WebRequestExecutor() { ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._webRequest = null;
    this._resultObject = null;
    }
    function Sys$Net$WebRequestExecutor$get_webRequest() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._webRequest;
    }
    function Sys$Net$WebRequestExecutor$_set_webRequest(value) {
    if (this.get_started()) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, ‘set_webRequest’));
    }
    this._webRequest = value;
    }
    function Sys$Net$WebRequestExecutor$get_started() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_responseAvailable() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_timedOut() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_aborted() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_responseData() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_statusCode() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_statusText() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_xml() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$get_object() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._resultObject) {
    this._resultObject = Sys.Serialization.JavaScriptSerializer.deserialize(this.get_responseData());
    }
    return this._resultObject;
    }
    function Sys$Net$WebRequestExecutor$executeRequest() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$abort() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$getResponseHeader(header) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “header”, type: String}
    ]);
    if (e) throw e;
    throw Error.notImplemented();
    }
    function Sys$Net$WebRequestExecutor$getAllResponseHeaders() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    throw Error.notImplemented();
    }
    Sys.Net.WebRequestExecutor.prototype = {
    get_webRequest: Sys$Net$WebRequestExecutor$get_webRequest,
    _set_webRequest: Sys$Net$WebRequestExecutor$_set_webRequest,
    get_started: Sys$Net$WebRequestExecutor$get_started,
    get_responseAvailable: Sys$Net$WebRequestExecutor$get_responseAvailable,
    get_timedOut: Sys$Net$WebRequestExecutor$get_timedOut,
    get_aborted: Sys$Net$WebRequestExecutor$get_aborted,
    get_responseData: Sys$Net$WebRequestExecutor$get_responseData,
    get_statusCode: Sys$Net$WebRequestExecutor$get_statusCode,
    get_statusText: Sys$Net$WebRequestExecutor$get_statusText,
    get_xml: Sys$Net$WebRequestExecutor$get_xml,
    get_object: Sys$Net$WebRequestExecutor$get_object,
    executeRequest: Sys$Net$WebRequestExecutor$executeRequest,
    abort: Sys$Net$WebRequestExecutor$abort,
    getResponseHeader: Sys$Net$WebRequestExecutor$getResponseHeader,
    getAllResponseHeaders: Sys$Net$WebRequestExecutor$getAllResponseHeaders
    }
    Sys.Net.WebRequestExecutor.registerClass(‘Sys.Net.WebRequestExecutor’);

    Sys.Net.XMLDOM = function Sys$Net$XMLDOM(markup) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “markup”, type: String}
    ]);
    if (e) throw e;
    if (!window.DOMParser) {
    var progIDs = [ ‘Msxml2.DOMDocument.3.0’, ‘Msxml2.DOMDocument’ ];
    for (var i = 0, l = progIDs.length; i < l; i++) { try { var xmlDOM = new ActiveXObject(progIDs[i]); xmlDOM.async = false; xmlDOM.loadXML(markup); xmlDOM.setProperty('SelectionLanguage', 'XPath'); return xmlDOM; } catch (ex) { } } } else { try { var domParser = new window.DOMParser(); return domParser.parseFromString(markup, 'text/xml'); } catch (ex) { } } return null; } Sys.Net.XMLHttpExecutor = function Sys$Net$XMLHttpExecutor() { /// if (arguments.length !== 0) throw Error.parameterCount();
    Sys.Net.XMLHttpExecutor.initializeBase(this);
    var _this = this;
    this._xmlHttpRequest = null;
    this._webRequest = null;
    this._responseAvailable = false;
    this._timedOut = false;
    this._timer = null;
    this._aborted = false;
    this._started = false;
    this._onReadyStateChange = (function () {

    if (_this._xmlHttpRequest.readyState === 4 ) {
    try {
    if (typeof(_this._xmlHttpRequest.status) === “undefined”) {
    return;
    }
    }
    catch(ex) {
    return;
    }

    _this._clearTimer();
    _this._responseAvailable = true;
    _this._webRequest.completed(Sys.EventArgs.Empty);
    if (_this._xmlHttpRequest != null) {
    _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
    _this._xmlHttpRequest = null;
    }
    }
    });
    this._clearTimer = (function() {
    if (_this._timer != null) {
    window.clearTimeout(_this._timer);
    _this._timer = null;
    }
    });
    this._onTimeout = (function() {
    if (!_this._responseAvailable) {
    _this._clearTimer();
    _this._timedOut = true;
    _this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
    _this._xmlHttpRequest.abort();
    _this._webRequest.completed(Sys.EventArgs.Empty);
    _this._xmlHttpRequest = null;
    }
    });
    }
    function Sys$Net$XMLHttpExecutor$get_timedOut() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._timedOut;
    }
    function Sys$Net$XMLHttpExecutor$get_started() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._started;
    }
    function Sys$Net$XMLHttpExecutor$get_responseAvailable() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._responseAvailable;
    }
    function Sys$Net$XMLHttpExecutor$get_aborted() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._aborted;
    }
    function Sys$Net$XMLHttpExecutor$executeRequest() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._webRequest = this.get_webRequest();
    if (this._started) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOnceStarted, ‘executeRequest’));
    }
    if (this._webRequest === null) {
    throw Error.invalidOperation(Sys.Res.nullWebRequest);
    }
    var body = this._webRequest.get_body();
    var headers = this._webRequest.get_headers();
    this._xmlHttpRequest = new XMLHttpRequest();
    this._xmlHttpRequest.onreadystatechange = this._onReadyStateChange;
    var verb = this._webRequest.get_httpVerb();
    this._xmlHttpRequest.open(verb, this._webRequest.getResolvedUrl(), true );
    this._xmlHttpRequest.setRequestHeader(“X-Requested-With”, “XMLHttpRequest”);
    if (headers) {
    for (var header in headers) {
    var val = headers[header];
    if (typeof(val) !== “function”)
    this._xmlHttpRequest.setRequestHeader(header, val);
    }
    }
    if (verb.toLowerCase() === “post”) {
    if ((headers === null) || !headers[‘Content-Type’]) {
    this._xmlHttpRequest.setRequestHeader(‘Content-Type’, ‘application/x-www-form-urlencoded; charset=utf-8’);
    }
    if (!body) {
    body = “”;
    }
    }
    var timeout = this._webRequest.get_timeout();
    if (timeout > 0) {
    this._timer = window.setTimeout(Function.createDelegate(this, this._onTimeout), timeout);
    }
    this._xmlHttpRequest.send(body);
    this._started = true;
    }
    function Sys$Net$XMLHttpExecutor$getResponseHeader(header) {
    ///

    /// ///
    var e = Function._validateParams(arguments, [
    {name: “header”, type: String}
    ]);
    if (e) throw e;
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘getResponseHeader’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘getResponseHeader’));
    }
    var result;
    try {
    result = this._xmlHttpRequest.getResponseHeader(header);
    } catch (e) {
    }
    if (!result) result = “”;
    return result;
    }
    function Sys$Net$XMLHttpExecutor$getAllResponseHeaders() {
    ///

    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘getAllResponseHeaders’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘getAllResponseHeaders’));
    }
    return this._xmlHttpRequest.getAllResponseHeaders();
    }
    function Sys$Net$XMLHttpExecutor$get_responseData() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘get_responseData’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘get_responseData’));
    }
    return this._xmlHttpRequest.responseText;
    }
    function Sys$Net$XMLHttpExecutor$get_statusCode() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘get_statusCode’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘get_statusCode’));
    }
    var result = 0;
    try {
    result = this._xmlHttpRequest.status;
    }
    catch(ex) {
    }
    return result;
    }
    function Sys$Net$XMLHttpExecutor$get_statusText() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘get_statusText’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘get_statusText’));
    }
    return this._xmlHttpRequest.statusText;
    }
    function Sys$Net$XMLHttpExecutor$get_xml() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._responseAvailable) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallBeforeResponse, ‘get_xml’));
    }
    if (!this._xmlHttpRequest) {
    throw Error.invalidOperation(String.format(Sys.Res.cannotCallOutsideHandler, ‘get_xml’));
    }
    var xml = this._xmlHttpRequest.responseXML;
    if (!xml || !xml.documentElement) {
    xml = Sys.Net.XMLDOM(this._xmlHttpRequest.responseText);
    if (!xml || !xml.documentElement)
    return null;
    }
    else if (navigator.userAgent.indexOf(‘MSIE’) !== -1) {
    xml.setProperty(‘SelectionLanguage’, ‘XPath’);
    }
    if (xml.documentElement.namespaceURI === “http://web.archive.org/web/20130914123623/http://www.mozilla.org/newlayout/xml/parsererror.xml” &&
    xml.documentElement.tagName === “parsererror”) {
    return null;
    }

    if (xml.documentElement.firstChild && xml.documentElement.firstChild.tagName === “parsererror”) {
    return null;
    }

    return xml;
    }
    function Sys$Net$XMLHttpExecutor$abort() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (!this._started) {
    throw Error.invalidOperation(Sys.Res.cannotAbortBeforeStart);
    }
    if (this._aborted || this._responseAvailable || this._timedOut)
    return;
    this._aborted = true;
    this._clearTimer();
    if (this._xmlHttpRequest && !this._responseAvailable) {
    this._xmlHttpRequest.onreadystatechange = Function.emptyMethod;
    this._xmlHttpRequest.abort();

    this._xmlHttpRequest = null;
    this._webRequest.completed(Sys.EventArgs.Empty);
    }
    }
    Sys.Net.XMLHttpExecutor.prototype = {
    get_timedOut: Sys$Net$XMLHttpExecutor$get_timedOut,
    get_started: Sys$Net$XMLHttpExecutor$get_started,
    get_responseAvailable: Sys$Net$XMLHttpExecutor$get_responseAvailable,
    get_aborted: Sys$Net$XMLHttpExecutor$get_aborted,
    executeRequest: Sys$Net$XMLHttpExecutor$executeRequest,
    getResponseHeader: Sys$Net$XMLHttpExecutor$getResponseHeader,
    getAllResponseHeaders: Sys$Net$XMLHttpExecutor$getAllResponseHeaders,
    get_responseData: Sys$Net$XMLHttpExecutor$get_responseData,
    get_statusCode: Sys$Net$XMLHttpExecutor$get_statusCode,
    get_statusText: Sys$Net$XMLHttpExecutor$get_statusText,
    get_xml: Sys$Net$XMLHttpExecutor$get_xml,
    abort: Sys$Net$XMLHttpExecutor$abort
    }
    Sys.Net.XMLHttpExecutor.registerClass(‘Sys.Net.XMLHttpExecutor’, Sys.Net.WebRequestExecutor);

    Sys.Net._WebRequestManager = function Sys$Net$_WebRequestManager() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._defaultTimeout = 0;
    this._defaultExecutorType = “Sys.Net.XMLHttpExecutor”;
    }
    function Sys$Net$_WebRequestManager$add_invokingRequest(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().addHandler(“invokingRequest”, handler);
    }
    function Sys$Net$_WebRequestManager$remove_invokingRequest(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().removeHandler(“invokingRequest”, handler);
    }
    function Sys$Net$_WebRequestManager$add_completedRequest(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().addHandler(“completedRequest”, handler);
    }
    function Sys$Net$_WebRequestManager$remove_completedRequest(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().removeHandler(“completedRequest”, handler);
    }
    function Sys$Net$_WebRequestManager$_get_eventHandlerList() {
    if (!this._events) {
    this._events = new Sys.EventHandlerList();
    }
    return this._events;
    }
    function Sys$Net$_WebRequestManager$get_defaultTimeout() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._defaultTimeout;
    }
    function Sys$Net$_WebRequestManager$set_defaultTimeout(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Number}]);
    if (e) throw e;
    if (value < 0) { throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout); } this._defaultTimeout = value; } function Sys$Net$_WebRequestManager$get_defaultExecutorType() { ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._defaultExecutorType;
    }
    function Sys$Net$_WebRequestManager$set_defaultExecutorType(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    this._defaultExecutorType = value;
    }
    function Sys$Net$_WebRequestManager$executeRequest(webRequest) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “webRequest”, type: Sys.Net.WebRequest}
    ]);
    if (e) throw e;
    var executor = webRequest.get_executor();
    if (!executor) {
    var failed = false;
    try {
    var executorType = eval(this._defaultExecutorType);
    executor = new executorType();
    } catch (e) {
    failed = true;
    }
    if (failed || !Sys.Net.WebRequestExecutor.isInstanceOfType(executor) || !executor) {
    throw Error.argument(“defaultExecutorType”, String.format(Sys.Res.invalidExecutorType, this._defaultExecutorType));
    }
    webRequest.set_executor(executor);
    }
    if (executor.get_aborted()) {
    return;
    }
    var evArgs = new Sys.Net.NetworkRequestEventArgs(webRequest);
    var handler = this._get_eventHandlerList().getHandler(“invokingRequest”);
    if (handler) {
    handler(this, evArgs);
    }
    if (!evArgs.get_cancel()) {
    executor.executeRequest();
    }
    }
    Sys.Net._WebRequestManager.prototype = {
    add_invokingRequest: Sys$Net$_WebRequestManager$add_invokingRequest,
    remove_invokingRequest: Sys$Net$_WebRequestManager$remove_invokingRequest,
    add_completedRequest: Sys$Net$_WebRequestManager$add_completedRequest,
    remove_completedRequest: Sys$Net$_WebRequestManager$remove_completedRequest,
    _get_eventHandlerList: Sys$Net$_WebRequestManager$_get_eventHandlerList,
    get_defaultTimeout: Sys$Net$_WebRequestManager$get_defaultTimeout,
    set_defaultTimeout: Sys$Net$_WebRequestManager$set_defaultTimeout,
    get_defaultExecutorType: Sys$Net$_WebRequestManager$get_defaultExecutorType,
    set_defaultExecutorType: Sys$Net$_WebRequestManager$set_defaultExecutorType,
    executeRequest: Sys$Net$_WebRequestManager$executeRequest
    }
    Sys.Net._WebRequestManager.registerClass(‘Sys.Net._WebRequestManager’);
    Sys.Net.WebRequestManager = new Sys.Net._WebRequestManager();

    Sys.Net.NetworkRequestEventArgs = function Sys$Net$NetworkRequestEventArgs(webRequest) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “webRequest”, type: Sys.Net.WebRequest}
    ]);
    if (e) throw e;
    Sys.Net.NetworkRequestEventArgs.initializeBase(this);
    this._webRequest = webRequest;
    }
    function Sys$Net$NetworkRequestEventArgs$get_webRequest() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._webRequest;
    }
    Sys.Net.NetworkRequestEventArgs.prototype = {
    get_webRequest: Sys$Net$NetworkRequestEventArgs$get_webRequest
    }
    Sys.Net.NetworkRequestEventArgs.registerClass(‘Sys.Net.NetworkRequestEventArgs’, Sys.CancelEventArgs);

    Sys.Net.WebRequest = function Sys$Net$WebRequest() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._url = “”;
    this._headers = { };
    this._body = null;
    this._userContext = null;
    this._httpVerb = null;
    this._executor = null;
    this._invokeCalled = false;
    this._timeout = 0;
    }
    function Sys$Net$WebRequest$add_completed(handler) {
    ///

    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().addHandler(“completed”, handler);
    }
    function Sys$Net$WebRequest$remove_completed(handler) {
    var e = Function._validateParams(arguments, [{name: “handler”, type: Function}]);
    if (e) throw e;
    this._get_eventHandlerList().removeHandler(“completed”, handler);
    }
    function Sys$Net$WebRequest$completed(eventArgs) {
    ///

    /// var e = Function._validateParams(arguments, [
    {name: “eventArgs”, type: Sys.EventArgs}
    ]);
    if (e) throw e;
    var handler = Sys.Net.WebRequestManager._get_eventHandlerList().getHandler(“completedRequest”);
    if (handler) {
    handler(this._executor, eventArgs);
    }
    handler = this._get_eventHandlerList().getHandler(“completed”);
    if (handler) {
    handler(this._executor, eventArgs);
    }
    }
    function Sys$Net$WebRequest$_get_eventHandlerList() {
    if (!this._events) {
    this._events = new Sys.EventHandlerList();
    }
    return this._events;
    }
    function Sys$Net$WebRequest$get_url() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._url;
    }
    function Sys$Net$WebRequest$set_url(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    this._url = value;
    }
    function Sys$Net$WebRequest$get_headers() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._headers;
    }
    function Sys$Net$WebRequest$get_httpVerb() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._httpVerb === null) {
    if (this._body === null) {
    return “GET”;
    }
    return “POST”;
    }
    return this._httpVerb;
    }
    function Sys$Net$WebRequest$set_httpVerb(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    if (value.length === 0) {
    throw Error.argument(‘value’, Sys.Res.invalidHttpVerb);
    }
    this._httpVerb = value;
    }
    function Sys$Net$WebRequest$get_body() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._body;
    }
    function Sys$Net$WebRequest$set_body(value) {
    var e = Function._validateParams(arguments, [{name: “value”, mayBeNull: true}]);
    if (e) throw e;
    this._body = value;
    }
    function Sys$Net$WebRequest$get_userContext() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._userContext;
    }
    function Sys$Net$WebRequest$set_userContext(value) {
    var e = Function._validateParams(arguments, [{name: “value”, mayBeNull: true}]);
    if (e) throw e;
    this._userContext = value;
    }
    function Sys$Net$WebRequest$get_executor() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._executor;
    }
    function Sys$Net$WebRequest$set_executor(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Sys.Net.WebRequestExecutor}]);
    if (e) throw e;
    if (this._executor !== null && this._executor.get_started()) {
    throw Error.invalidOperation(Sys.Res.setExecutorAfterActive);
    }
    this._executor = value;
    this._executor._set_webRequest(this);
    }
    function Sys$Net$WebRequest$get_timeout() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._timeout === 0) {
    return Sys.Net.WebRequestManager.get_defaultTimeout();
    }
    return this._timeout;
    }
    function Sys$Net$WebRequest$set_timeout(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Number}]);
    if (e) throw e;
    if (value < 0) { throw Error.argumentOutOfRange("value", value, Sys.Res.invalidTimeout); } this._timeout = value; } function Sys$Net$WebRequest$getResolvedUrl() { /// ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return Sys.Net.WebRequest._resolveUrl(this._url);
    }
    function Sys$Net$WebRequest$invoke() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    if (this._invokeCalled) {
    throw Error.invalidOperation(Sys.Res.invokeCalledTwice);
    }
    Sys.Net.WebRequestManager.executeRequest(this);
    this._invokeCalled = true;
    }
    Sys.Net.WebRequest.prototype = {
    add_completed: Sys$Net$WebRequest$add_completed,
    remove_completed: Sys$Net$WebRequest$remove_completed,
    completed: Sys$Net$WebRequest$completed,
    _get_eventHandlerList: Sys$Net$WebRequest$_get_eventHandlerList,
    get_url: Sys$Net$WebRequest$get_url,
    set_url: Sys$Net$WebRequest$set_url,
    get_headers: Sys$Net$WebRequest$get_headers,
    get_httpVerb: Sys$Net$WebRequest$get_httpVerb,
    set_httpVerb: Sys$Net$WebRequest$set_httpVerb,
    get_body: Sys$Net$WebRequest$get_body,
    set_body: Sys$Net$WebRequest$set_body,
    get_userContext: Sys$Net$WebRequest$get_userContext,
    set_userContext: Sys$Net$WebRequest$set_userContext,
    get_executor: Sys$Net$WebRequest$get_executor,
    set_executor: Sys$Net$WebRequest$set_executor,
    get_timeout: Sys$Net$WebRequest$get_timeout,
    set_timeout: Sys$Net$WebRequest$set_timeout,
    getResolvedUrl: Sys$Net$WebRequest$getResolvedUrl,
    invoke: Sys$Net$WebRequest$invoke
    }
    Sys.Net.WebRequest._resolveUrl = function Sys$Net$WebRequest$_resolveUrl(url, baseUrl) {
    if (url && url.indexOf(‘://’) !== -1) {
    return url;
    }
    if (!baseUrl || baseUrl.length === 0) {
    var baseElement = document.getElementsByTagName(‘base’)[0];
    if (baseElement && baseElement.href && baseElement.href.length > 0) {
    baseUrl = baseElement.href;
    }
    else {
    baseUrl = document.URL;
    }
    }
    var qsStart = baseUrl.indexOf(‘?’);
    if (qsStart !== -1) {
    baseUrl = baseUrl.substr(0, qsStart);
    }
    qsStart = baseUrl.indexOf(‘#’);
    if (qsStart !== -1) {
    baseUrl = baseUrl.substr(0, qsStart);
    }
    baseUrl = baseUrl.substr(0, baseUrl.lastIndexOf(‘/’) + 1);
    if (!url || url.length === 0) {
    return baseUrl;
    }
    if (url.charAt(0) === ‘/’) {
    var slashslash = baseUrl.indexOf(‘://’);
    if (slashslash === -1) {
    throw Error.argument(“baseUrl”, Sys.Res.badBaseUrl1);
    }
    var nextSlash = baseUrl.indexOf(‘/’, slashslash + 3);
    if (nextSlash === -1) {
    throw Error.argument(“baseUrl”, Sys.Res.badBaseUrl2);
    }
    return baseUrl.substr(0, nextSlash) + url;
    }
    else {
    var lastSlash = baseUrl.lastIndexOf(‘/’);
    if (lastSlash === -1) {
    throw Error.argument(“baseUrl”, Sys.Res.badBaseUrl3);
    }
    return baseUrl.substr(0, lastSlash+1) + url;
    }
    }
    Sys.Net.WebRequest._createQueryString = function Sys$Net$WebRequest$_createQueryString(queryString, encodeMethod, addParams) {
    encodeMethod = encodeMethod || encodeURIComponent;
    var i = 0, obj, val, arg, sb = new Sys.StringBuilder();
    if (queryString) {
    for (arg in queryString) {
    obj = queryString[arg];
    if (typeof(obj) === “function”) continue;
    val = Sys.Serialization.JavaScriptSerializer.serialize(obj);
    if (i++) {
    sb.append(‘&’);
    }
    sb.append(arg);
    sb.append(‘=’);
    sb.append(encodeMethod(val));
    }
    }
    if (addParams) {
    if (i) {
    sb.append(‘&’);
    }
    sb.append(addParams);
    }
    return sb.toString();
    }
    Sys.Net.WebRequest._createUrl = function Sys$Net$WebRequest$_createUrl(url, queryString, addParams) {
    if (!queryString && !addParams) {
    return url;
    }
    var qs = Sys.Net.WebRequest._createQueryString(queryString, null, addParams);
    return qs.length
    ? url + ((url && url.indexOf(‘?’) >= 0) ? “&” : “?”) + qs
    : url;
    }
    Sys.Net.WebRequest.registerClass(‘Sys.Net.WebRequest’);

    Sys._ScriptLoaderTask = function Sys$_ScriptLoaderTask(scriptElement, completedCallback) {
    ///

    /// /// var e = Function._validateParams(arguments, [
    {name: “scriptElement”, domElement: true},
    {name: “completedCallback”, type: Function}
    ]);
    if (e) throw e;
    this._scriptElement = scriptElement;
    this._completedCallback = completedCallback;
    }
    function Sys$_ScriptLoaderTask$get_scriptElement() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._scriptElement;
    }
    function Sys$_ScriptLoaderTask$dispose() {
    if(this._disposed) {
    return;
    }
    this._disposed = true;
    this._removeScriptElementHandlers();
    Sys._ScriptLoaderTask._clearScript(this._scriptElement);
    this._scriptElement = null;
    }
    function Sys$_ScriptLoaderTask$execute() {
    ///

    if (arguments.length !== 0) throw Error.parameterCount();
    this._addScriptElementHandlers();
    var headElements = document.getElementsByTagName(‘head’);
    if (headElements.length === 0) {
    throw new Error.invalidOperation(Sys.Res.scriptLoadFailedNoHead);
    }
    else {
    headElements[0].appendChild(this._scriptElement);
    }
    }
    function Sys$_ScriptLoaderTask$_addScriptElementHandlers() {
    this._scriptLoadDelegate = Function.createDelegate(this, this._scriptLoadHandler);

    if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {
    this._scriptElement.readyState = ‘loaded’;
    $addHandler(this._scriptElement, ‘load’, this._scriptLoadDelegate);
    }
    else {
    $addHandler(this._scriptElement, ‘readystatechange’, this._scriptLoadDelegate);
    }
    if (this._scriptElement.addEventListener) {
    this._scriptErrorDelegate = Function.createDelegate(this, this._scriptErrorHandler);
    this._scriptElement.addEventListener(‘error’, this._scriptErrorDelegate, false);
    }
    }
    function Sys$_ScriptLoaderTask$_removeScriptElementHandlers() {
    if(this._scriptLoadDelegate) {
    var scriptElement = this.get_scriptElement();
    if (Sys.Browser.agent !== Sys.Browser.InternetExplorer) {
    $removeHandler(scriptElement, ‘load’, this._scriptLoadDelegate);
    }
    else {
    $removeHandler(scriptElement, ‘readystatechange’, this._scriptLoadDelegate);
    }
    if (this._scriptErrorDelegate) {
    this._scriptElement.removeEventListener(‘error’, this._scriptErrorDelegate, false);
    this._scriptErrorDelegate = null;
    }
    this._scriptLoadDelegate = null;
    }
    }
    function Sys$_ScriptLoaderTask$_scriptErrorHandler() {
    if(this._disposed) {
    return;
    }

    this._completedCallback(this.get_scriptElement(), false);
    }
    function Sys$_ScriptLoaderTask$_scriptLoadHandler() {
    if(this._disposed) {
    return;
    }
    var scriptElement = this.get_scriptElement();
    if ((scriptElement.readyState !== ‘loaded’) &&
    (scriptElement.readyState !== ‘complete’)) {
    return;
    }

    this._completedCallback(scriptElement, true);
    }
    Sys._ScriptLoaderTask.prototype = {
    get_scriptElement: Sys$_ScriptLoaderTask$get_scriptElement,
    dispose: Sys$_ScriptLoaderTask$dispose,
    execute: Sys$_ScriptLoaderTask$execute,
    _addScriptElementHandlers: Sys$_ScriptLoaderTask$_addScriptElementHandlers,
    _removeScriptElementHandlers: Sys$_ScriptLoaderTask$_removeScriptElementHandlers,
    _scriptErrorHandler: Sys$_ScriptLoaderTask$_scriptErrorHandler,
    _scriptLoadHandler: Sys$_ScriptLoaderTask$_scriptLoadHandler
    }
    Sys._ScriptLoaderTask.registerClass(“Sys._ScriptLoaderTask”, null, Sys.IDisposable);
    Sys._ScriptLoaderTask._clearScript = function Sys$_ScriptLoaderTask$_clearScript(scriptElement) {
    if (!Sys.Debug.isDebug) {
    scriptElement.parentNode.removeChild(scriptElement);
    }
    }
    Type.registerNamespace(‘Sys.Net’);

    Sys.Net.WebServiceProxy = function Sys$Net$WebServiceProxy() {
    }
    function Sys$Net$WebServiceProxy$get_timeout() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._timeout || 0;
    }
    function Sys$Net$WebServiceProxy$set_timeout(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Number}]);
    if (e) throw e;
    if (value < 0) { throw Error.argumentOutOfRange('value', value, Sys.Res.invalidTimeout); } this._timeout = value; } function Sys$Net$WebServiceProxy$get_defaultUserContext() { ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return (typeof(this._userContext) === “undefined”) ? null : this._userContext;
    }
    function Sys$Net$WebServiceProxy$set_defaultUserContext(value) {
    var e = Function._validateParams(arguments, [{name: “value”, mayBeNull: true}]);
    if (e) throw e;
    this._userContext = value;
    }
    function Sys$Net$WebServiceProxy$get_defaultSucceededCallback() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._succeeded || null;
    }
    function Sys$Net$WebServiceProxy$set_defaultSucceededCallback(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Function, mayBeNull: true}]);
    if (e) throw e;
    this._succeeded = value;
    }
    function Sys$Net$WebServiceProxy$get_defaultFailedCallback() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._failed || null;
    }
    function Sys$Net$WebServiceProxy$set_defaultFailedCallback(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Function, mayBeNull: true}]);
    if (e) throw e;
    this._failed = value;
    }
    function Sys$Net$WebServiceProxy$get_enableJsonp() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return !!this._jsonp;
    }
    function Sys$Net$WebServiceProxy$set_enableJsonp(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: Boolean}]);
    if (e) throw e;
    this._jsonp = value;
    }
    function Sys$Net$WebServiceProxy$get_path() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._path || null;
    }
    function Sys$Net$WebServiceProxy$set_path(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    this._path = value;
    }
    function Sys$Net$WebServiceProxy$get_jsonpCallbackParameter() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._callbackParameter || “callback”;
    }
    function Sys$Net$WebServiceProxy$set_jsonpCallbackParameter(value) {
    var e = Function._validateParams(arguments, [{name: “value”, type: String}]);
    if (e) throw e;
    this._callbackParameter = value;
    }
    function Sys$Net$WebServiceProxy$_invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext) {
    ///

    /// /// /// /// /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “servicePath”, type: String},
    {name: “methodName”, type: String},
    {name: “useGet”, type: Boolean},
    {name: “params”},
    {name: “onSuccess”, type: Function, mayBeNull: true, optional: true},
    {name: “onFailure”, type: Function, mayBeNull: true, optional: true},
    {name: “userContext”, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    onSuccess = onSuccess || this.get_defaultSucceededCallback();
    onFailure = onFailure || this.get_defaultFailedCallback();
    if (userContext === null || typeof userContext === ‘undefined’) userContext = this.get_defaultUserContext();
    return Sys.Net.WebServiceProxy.invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, this.get_timeout(), this.get_enableJsonp(), this.get_jsonpCallbackParameter());
    }
    Sys.Net.WebServiceProxy.prototype = {
    get_timeout: Sys$Net$WebServiceProxy$get_timeout,
    set_timeout: Sys$Net$WebServiceProxy$set_timeout,
    get_defaultUserContext: Sys$Net$WebServiceProxy$get_defaultUserContext,
    set_defaultUserContext: Sys$Net$WebServiceProxy$set_defaultUserContext,
    get_defaultSucceededCallback: Sys$Net$WebServiceProxy$get_defaultSucceededCallback,
    set_defaultSucceededCallback: Sys$Net$WebServiceProxy$set_defaultSucceededCallback,
    get_defaultFailedCallback: Sys$Net$WebServiceProxy$get_defaultFailedCallback,
    set_defaultFailedCallback: Sys$Net$WebServiceProxy$set_defaultFailedCallback,
    get_enableJsonp: Sys$Net$WebServiceProxy$get_enableJsonp,
    set_enableJsonp: Sys$Net$WebServiceProxy$set_enableJsonp,
    get_path: Sys$Net$WebServiceProxy$get_path,
    set_path: Sys$Net$WebServiceProxy$set_path,
    get_jsonpCallbackParameter: Sys$Net$WebServiceProxy$get_jsonpCallbackParameter,
    set_jsonpCallbackParameter: Sys$Net$WebServiceProxy$set_jsonpCallbackParameter,
    _invoke: Sys$Net$WebServiceProxy$_invoke
    }
    Sys.Net.WebServiceProxy.registerClass(‘Sys.Net.WebServiceProxy’);
    Sys.Net.WebServiceProxy.invoke = function Sys$Net$WebServiceProxy$invoke(servicePath, methodName, useGet, params, onSuccess, onFailure, userContext, timeout, enableJsonp, jsonpCallbackParameter) {
    ///

    /// /// /// /// /// /// /// /// /// /// ///
    var e = Function._validateParams(arguments, [
    {name: “servicePath”, type: String},
    {name: “methodName”, type: String, mayBeNull: true, optional: true},
    {name: “useGet”, type: Boolean, optional: true},
    {name: “params”, mayBeNull: true, optional: true},
    {name: “onSuccess”, type: Function, mayBeNull: true, optional: true},
    {name: “onFailure”, type: Function, mayBeNull: true, optional: true},
    {name: “userContext”, mayBeNull: true, optional: true},
    {name: “timeout”, type: Number, optional: true},
    {name: “enableJsonp”, type: Boolean, mayBeNull: true, optional: true},
    {name: “jsonpCallbackParameter”, type: String, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    var schemeHost = (enableJsonp !== false) ? Sys.Net.WebServiceProxy._xdomain.exec(servicePath) : null,
    tempCallback, jsonp = schemeHost && (schemeHost.length === 3) &&
    ((schemeHost[1] !== location.protocol) || (schemeHost[2] !== location.host));
    useGet = jsonp || useGet;
    if (jsonp) {
    jsonpCallbackParameter = jsonpCallbackParameter || “callback”;
    tempCallback = “_jsonp” + Sys._jsonp++;
    }
    if (!params) params = {};
    var urlParams = params;
    if (!useGet || !urlParams) urlParams = {};
    var script, error, timeoutcookie = null, loader, body = null,
    url = Sys.Net.WebRequest._createUrl(methodName
    ? (servicePath+”/”+encodeURIComponent(methodName))
    : servicePath, urlParams, jsonp ? (jsonpCallbackParameter + “=Sys.” + tempCallback) : null);
    if (jsonp) {
    script = document.createElement(“script”);
    script.src = url;
    loader = new Sys._ScriptLoaderTask(script, function(script, loaded) {
    if (!loaded || tempCallback) {
    jsonpComplete({ Message: String.format(Sys.Res.webServiceFailedNoMsg, methodName) }, -1);
    }
    });
    function jsonpComplete(data, statusCode) {
    if (timeoutcookie !== null) {
    window.clearTimeout(timeoutcookie);
    timeoutcookie = null;
    }
    loader.dispose();
    delete Sys[tempCallback];
    tempCallback = null;
    if ((typeof(statusCode) !== “undefined”) && (statusCode !== 200)) {
    if (onFailure) {
    error = new Sys.Net.WebServiceError(false,
    data.Message || String.format(Sys.Res.webServiceFailedNoMsg, methodName),
    data.StackTrace || null,
    data.ExceptionType || null,
    data);
    error._statusCode = statusCode;
    onFailure(error, userContext, methodName);
    }
    else {
    if (data.StackTrace && data.Message) {
    error = data.StackTrace + “– ” + data.Message;
    }
    else {
    error = data.StackTrace || data.Message;
    }
    error = String.format(error ? Sys.Res.webServiceFailed : Sys.Res.webServiceFailedNoMsg, methodName, error);
    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
    }
    }
    else if (onSuccess) {
    onSuccess(data, userContext, methodName);
    }
    }
    Sys[tempCallback] = jsonpComplete;
    loader.execute();
    return null;
    }
    var request = new Sys.Net.WebRequest();
    request.set_url(url);
    request.get_headers()[‘Content-Type’] = ‘application/json; charset=utf-8’;
    if (!useGet) {
    body = Sys.Serialization.JavaScriptSerializer.serialize(params);
    if (body === “{}”) body = “”;
    }
    request.set_body(body);
    request.add_completed(onComplete);
    if (timeout && timeout > 0) request.set_timeout(timeout);
    request.invoke();

    function onComplete(response, eventArgs) {
    if (response.get_responseAvailable()) {
    var statusCode = response.get_statusCode();
    var result = null;

    try {
    var contentType = response.getResponseHeader(“Content-Type”);
    if (contentType.startsWith(“application/json”)) {
    result = response.get_object();
    }
    else if (contentType.startsWith(“text/xml”)) {
    result = response.get_xml();
    }
    else {
    result = response.get_responseData();
    }
    } catch (ex) {
    }
    var error = response.getResponseHeader(“jsonerror”);
    var errorObj = (error === “true”);
    if (errorObj) {
    if (result) {
    result = new Sys.Net.WebServiceError(false, result.Message, result.StackTrace, result.ExceptionType, result);
    }
    }
    else if (contentType.startsWith(“application/json”)) {
    result = (!result || (typeof(result.d) === “undefined”)) ? result : result.d;
    }
    if (((statusCode < 200) || (statusCode >= 300)) || errorObj) {
    if (onFailure) {
    if (!result || !errorObj) {
    result = new Sys.Net.WebServiceError(false , String.format(Sys.Res.webServiceFailedNoMsg, methodName));
    }
    result._statusCode = statusCode;
    onFailure(result, userContext, methodName);
    }
    else {
    if (result && errorObj) {
    error = result.get_exceptionType() + “– ” + result.get_message();
    }
    else {
    error = response.get_responseData();
    }
    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
    }
    }
    else if (onSuccess) {
    onSuccess(result, userContext, methodName);
    }
    }
    else {
    var msg;
    if (response.get_timedOut()) {
    msg = String.format(Sys.Res.webServiceTimedOut, methodName);
    }
    else {
    msg = String.format(Sys.Res.webServiceFailedNoMsg, methodName)
    }
    if (onFailure) {
    onFailure(new Sys.Net.WebServiceError(response.get_timedOut(), msg, “”, “”), userContext, methodName);
    }
    else {
    throw Sys.Net.WebServiceProxy._createFailedError(methodName, msg);
    }
    }
    }
    return request;
    }
    Sys.Net.WebServiceProxy._createFailedError = function Sys$Net$WebServiceProxy$_createFailedError(methodName, errorMessage) {
    var displayMessage = “Sys.Net.WebServiceFailedException: ” + errorMessage;
    var e = Error.create(displayMessage, { ‘name’: ‘Sys.Net.WebServiceFailedException’, ‘methodName’: methodName });
    e.popStackFrame();
    return e;
    }
    Sys.Net.WebServiceProxy._defaultFailedCallback = function Sys$Net$WebServiceProxy$_defaultFailedCallback(err, methodName) {
    var error = err.get_exceptionType() + “– ” + err.get_message();
    throw Sys.Net.WebServiceProxy._createFailedError(methodName, String.format(Sys.Res.webServiceFailed, methodName, error));
    }
    Sys.Net.WebServiceProxy._generateTypedConstructor = function Sys$Net$WebServiceProxy$_generateTypedConstructor(type) {
    return function(properties) {
    if (properties) {
    for (var name in properties) {
    this[name] = properties[name];
    }
    }
    this.__type = type;
    }
    }
    Sys._jsonp = 0;
    Sys.Net.WebServiceProxy._xdomain = /^\s*([a-zA-Z0-9\+\-\.]+\:)\/\/([^?#\/]+)/;

    Sys.Net.WebServiceError = function Sys$Net$WebServiceError(timedOut, message, stackTrace, exceptionType, errorObject) {
    ///

    /// /// /// /// /// var e = Function._validateParams(arguments, [
    {name: “timedOut”, type: Boolean},
    {name: “message”, type: String, mayBeNull: true},
    {name: “stackTrace”, type: String, mayBeNull: true, optional: true},
    {name: “exceptionType”, type: String, mayBeNull: true, optional: true},
    {name: “errorObject”, type: Object, mayBeNull: true, optional: true}
    ]);
    if (e) throw e;
    this._timedOut = timedOut;
    this._message = message;
    this._stackTrace = stackTrace;
    this._exceptionType = exceptionType;
    this._errorObject = errorObject;
    this._statusCode = -1;
    }
    function Sys$Net$WebServiceError$get_timedOut() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._timedOut;
    }
    function Sys$Net$WebServiceError$get_statusCode() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._statusCode;
    }
    function Sys$Net$WebServiceError$get_message() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._message;
    }
    function Sys$Net$WebServiceError$get_stackTrace() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._stackTrace || “”;
    }
    function Sys$Net$WebServiceError$get_exceptionType() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._exceptionType || “”;
    }
    function Sys$Net$WebServiceError$get_errorObject() {
    ///
    if (arguments.length !== 0) throw Error.parameterCount();
    return this._errorObject || null;
    }
    Sys.Net.WebServiceError.prototype = {
    get_timedOut: Sys$Net$WebServiceError$get_timedOut,
    get_statusCode: Sys$Net$WebServiceError$get_statusCode,
    get_message: Sys$Net$WebServiceError$get_message,
    get_stackTrace: Sys$Net$WebServiceError$get_stackTrace,
    get_exceptionType: Sys$Net$WebServiceError$get_exceptionType,
    get_errorObject: Sys$Net$WebServiceError$get_errorObject
    }
    Sys.Net.WebServiceError.registerClass(‘Sys.Net.WebServiceError’);

    Type.registerNamespace(‘Sys’);
    Sys.Res={
    “argumentInteger”:”Value must be an integer.”,
    “invokeCalledTwice”:”Cannot call invoke more than once.”,
    “webServiceFailed”:”The server method \u0027{0}\u0027 failed with the following error: {1}”,
    “argumentType”:”Object cannot be converted to the required type.”,
    “argumentNull”:”Value cannot be null.”,
    “scriptAlreadyLoaded”:”The script \u0027{0}\u0027 has been referenced multiple times. If referencing Microsoft AJAX scripts explicitly, set the MicrosoftAjaxMode property of the ScriptManager to Explicit.”,
    “scriptDependencyNotFound”:”The script \u0027{0}\u0027 failed to load because it is dependent on script \u0027{1}\u0027.”,
    “formatBadFormatSpecifier”:”Format specifier was invalid.”,
    “requiredScriptReferenceNotIncluded”:”\u0027{0}\u0027 requires that you have included a script reference to \u0027{1}\u0027.”,
    “webServiceFailedNoMsg”:”The server method \u0027{0}\u0027 failed.”,
    “argumentDomElement”:”Value must be a DOM element.”,
    “invalidExecutorType”:”Could not create a valid Sys.Net.WebRequestExecutor from: {0}.”,
    “cannotCallBeforeResponse”:”Cannot call {0} when responseAvailable is false.”,
    “actualValue”:”Actual value was {0}.”,
    “enumInvalidValue”:”\u0027{0}\u0027 is not a valid value for enum {1}.”,
    “scriptLoadFailed”:”The script \u0027{0}\u0027 could not be loaded.”,
    “parameterCount”:”Parameter count mismatch.”,
    “cannotDeserializeEmptyString”:”Cannot deserialize empty string.”,
    “formatInvalidString”:”Input string was not in a correct format.”,
    “invalidTimeout”:”Value must be greater than or equal to zero.”,
    “cannotAbortBeforeStart”:”Cannot abort when executor has not started.”,
    “argument”:”Value does not fall within the expected range.”,
    “cannotDeserializeInvalidJson”:”Cannot deserialize. The data does not correspond to valid JSON.”,
    “invalidHttpVerb”:”httpVerb cannot be set to an empty or null string.”,
    “nullWebRequest”:”Cannot call executeRequest with a null webRequest.”,
    “eventHandlerInvalid”:”Handler was not added through the Sys.UI.DomEvent.addHandler method.”,
    “cannotSerializeNonFiniteNumbers”:”Cannot serialize non finite numbers.”,
    “argumentUndefined”:”Value cannot be undefined.”,
    “webServiceInvalidReturnType”:”The server method \u0027{0}\u0027 returned an invalid type. Expected type: {1}”,
    “servicePathNotSet”:”The path to the web service has not been set.”,
    “argumentTypeWithTypes”:”Object of type \u0027{0}\u0027 cannot be converted to type \u0027{1}\u0027.”,
    “cannotCallOnceStarted”:”Cannot call {0} once started.”,
    “badBaseUrl1″:”Base URL does not contain ://.”,
    “badBaseUrl2″:”Base URL does not contain another /.”,
    “badBaseUrl3″:”Cannot find last / in base URL.”,
    “setExecutorAfterActive”:”Cannot set executor after it has become active.”,
    “paramName”:”Parameter name: {0}”,
    “nullReferenceInPath”:”Null reference while evaluating data path: \u0027{0}\u0027.”,
    “cannotCallOutsideHandler”:”Cannot call {0} outside of a completed event handler.”,
    “cannotSerializeObjectWithCycle”:”Cannot serialize object with cyclic reference within child properties.”,
    “format”:”One of the identified items was in an invalid format.”,
    “assertFailedCaller”:”Assertion Failed: {0}\r\nat {1}”,
    “argumentOutOfRange”:”Specified argument was out of the range of valid values.”,
    “webServiceTimedOut”:”The server method \u0027{0}\u0027 timed out.”,
    “notImplemented”:”The method or operation is not implemented.”,
    “assertFailed”:”Assertion Failed: {0}”,
    “invalidOperation”:”Operation is not valid due to the current state of the object.”,
    “breakIntoDebugger”:”{0}\r\n\r\nBreak into debugger?”,
    “argumentTypeName”:”Value is not the name of an existing type.”,
    “cantBeCalledAfterDispose”:”Can\u0027t be called after dispose.”,
    “componentCantSetIdAfterAddedToApp”:”The id property of a component can\u0027t be set after it\u0027s been added to the Application object.”,
    “behaviorDuplicateName”:”A behavior with name \u0027{0}\u0027 already exists or it is the name of an existing property on the target element.”,
    “notATypeName”:”Value is not a valid type name.”,
    “elementNotFound”:”An element with id \u0027{0}\u0027 could not be found.”,
    “stateMustBeStringDictionary”:”The state object can only have null and string fields.”,
    “boolTrueOrFalse”:”Value must be \u0027true\u0027 or \u0027false\u0027.”,
    “scriptLoadFailedNoHead”:”ScriptLoader requires pages to contain a \u003chead\u003e element.”,
    “stringFormatInvalid”:”The format string is invalid.”,
    “referenceNotFound”:”Component \u0027{0}\u0027 was not found.”,
    “enumReservedName”:”\u0027{0}\u0027 is a reserved name that can\u0027t be used as an enum value name.”,
    “circularParentChain”:”The chain of control parents can\u0027t have circular references.”,
    “namespaceContainsNonObject”:”Object {0} already exists and is not an object.”,
    “undefinedEvent”:”\u0027{0}\u0027 is not an event.”,
    “propertyUndefined”:”\u0027{0}\u0027 is not a property or an existing field.”,
    “observableConflict”:”Object already contains a member with the name \u0027{0}\u0027.”,
    “historyCannotEnableHistory”:”Cannot set enableHistory after initialization.”,
    “scriptLoadFailedDebug”:”The script \u0027{0}\u0027 failed to load. Check for:\r\n Inaccessible path.\r\n Script errors. (IE) Enable \u0027Display a notification about every script error\u0027 under advanced settings.”,
    “propertyNotWritable”:”\u0027{0}\u0027 is not a writable property.”,
    “enumInvalidValueName”:”\u0027{0}\u0027 is not a valid name for an enum value.”,
    “controlAlreadyDefined”:”A control is already associated with the element.”,
    “addHandlerCantBeUsedForError”:”Can\u0027t add a handler for the error event using this method. Please set the window.onerror property instead.”,
    “cantAddNonFunctionhandler”:”Can\u0027t add a handler that is not a function.”,
    “invalidNameSpace”:”Value is not a valid namespace identifier.”,
    “notAnInterface”:”Value is not a valid interface.”,
    “eventHandlerNotFunction”:”Handler must be a function.”,
    “propertyNotAnArray”:”\u0027{0}\u0027 is not an Array property.”,
    “namespaceContainsClass”:”Object {0} already exists as a class, enum, or interface.”,
    “typeRegisteredTwice”:”Type {0} has already been registered. The type may be defined multiple times or the script file that defines it may have already been loaded. A possible cause is a change of settings during a partial update.”,
    “cantSetNameAfterInit”:”The name property can\u0027t be set on this object after initialization.”,
    “historyMissingFrame”:”For the history feature to work in IE, the page must have an iFrame element with id \u0027__historyFrame\u0027 pointed to a page that gets its title from the \u0027title\u0027 query string parameter and calls Sys.Application._onIFrameLoad() on the parent window. This can be done by setting EnableHistory to true on ScriptManager.”,
    “appDuplicateComponent”:”Two components with the same id \u0027{0}\u0027 can\u0027t be added to the application.”,
    “historyCannotAddHistoryPointWithHistoryDisabled”:”A history point can only be added if enableHistory is set to true.”,
    “baseNotAClass”:”Value is not a class.”,
    “expectedElementOrId”:”Value must be a DOM element or DOM element Id.”,
    “methodNotFound”:”No method found with name \u0027{0}\u0027.”,
    “arrayParseBadFormat”:”Value must be a valid string representation for an array. It must start with a \u0027[\u0027 and end with a \u0027]\u0027.”,
    “stateFieldNameInvalid”:”State field names must not contain any \u0027=\u0027 characters.”,
    “cantSetId”:”The id property can\u0027t be set on this object.”,
    “stringFormatBraceMismatch”:”The format string contains an unmatched opening or closing brace.”,
    “enumValueNotInteger”:”An enumeration definition can only contain integer values.”,
    “propertyNullOrUndefined”:”Cannot set the properties of \u0027{0}\u0027 because it returned a null value.”,
    “argumentDomNode”:”Value must be a DOM element or a text node.”,
    “componentCantSetIdTwice”:”The id property of a component can\u0027t be set more than once.”,
    “createComponentOnDom”:”Value must be null for Components that are not Controls or Behaviors.”,
    “createNotComponent”:”{0} does not derive from Sys.Component.”,
    “createNoDom”:”Value must not be null for Controls and Behaviors.”,
    “cantAddWithoutId”:”Can\u0027t add a component that doesn\u0027t have an id.”,
    “urlTooLong”:”The history state must be small enough to not make the url larger than {0} characters.”,
    “notObservable”:”Instances of type \u0027{0}\u0027 cannot be observed.”,
    “badTypeName”:”Value is not the name of the type being registered or the name is a reserved word.”
    };

    /*
    FILE ARCHIVED ON 12:36:23 Sep 14, 2013 AND RETRIEVED FROM THE
    INTERNET ARCHIVE ON 06:37:27 Oct 23, 2017.
    JAVASCRIPT APPENDED BY WAYBACK MACHINE, COPYRIGHT INTERNET ARCHIVE.

    ALL OTHER CONTENT MAY ALSO BE PROTECTED BY COPYRIGHT (17 U.S.C.
    SECTION 108(a)(3)).
    */

    ;>