var digits = "0123456789"; 
 
var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz" 
 
var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
 
 
// whitespace characters 
var whitespace = " \t\n\r"; 
 
 
// decimal point character differs by language and culture 
var decimalPointDelimiter = "." 
 
 
// non-digit characters which are allowed in phone numbers 
var phoneNumberDelimiters = "()- "; 
 
 
// characters which are allowed in US phone numbers 
var validUSPhoneChars = digits + phoneNumberDelimiters; 
 
 
// characters which are allowed in international phone numbers 
// (a leading + is OK) 
var validWorldPhoneChars = digits + phoneNumberDelimiters + "+"; 
 
 
// non-digit characters which are allowed in  
// Social Security Numbers 
var SSNDelimiters = "- "; 
 
 
 
// characters which are allowed in Social Security Numbers 
var validSSNChars = digits + SSNDelimiters; 
 
 
 
// U.S. Social Security Numbers have 9 digits. 
// They are formatted as 123-45-6789. 
var digitsInSocialSecurityNumber = 9; 
 
 
 
// U.S. phone numbers have 10 digits. 
// They are formatted as 123 456 7890 or (123) 456-7890. 
var digitsInUSPhoneNumber = 10; 
 
 
 
// non-digit characters which are allowed in ZIP Codes 
var ZIPCodeDelimiters = "-"; 
 
 
 
// our preferred delimiter for reformatting ZIP Codes 
var ZIPCodeDelimeter = "-" 
 
 
// characters which are allowed in Social Security Numbers 
var validZIPCodeChars = digits + ZIPCodeDelimiters 
 
 
 
// U.S. ZIP codes have 5 or 9 digits. 
// They are formatted as 12345 or 12345-6789. 
var digitsInZIPCode1 = 5 
var digitsInZIPCode2 = 9 
 
 
// non-digit characters which are allowed in credit card numbers 
var creditCardDelimiters = " " 
 
 
// CONSTANT STRING DECLARATIONS 
// (grouped for ease of translation and localization) 
 
// m is an abbreviation for "missing" 
 
var mPrefix = "You did not enter a value into the " 
var mSuffix = " field. This is a required field. Please enter it now." 
 
// s is an abbreviation for "string" 
 
var sUSLastName = "Last Name" 
var sUSFirstName = "First Name" 
var sWorldLastName = "Family Name" 
var sWorldFirstName = "Given Name" 
var sTitle = "Title" 
var sCompanyName = "Company Name" 
var sUSAddress = "Street Address" 
var sWorldAddress = "Address" 
var sCity = "City" 
var sStateCode = "State Code" 
var sWorldState = "State, Province, or Prefecture" 
var sCountry = "Country" 
var sZIPCode = "ZIP Code" 
var sWorldPostalCode = "Postal Code" 
var sPhone = "Phone Number" 
var sFax = "Fax Number" 
var sDateOfBirth = "Date of Birth" 
var sExpirationDate = "Expiration Date" 
var sEmail = "Email" 
var sSSN = "Social Security Number" 
var sCreditCardNumber = "Credit Card Number" 
var sOtherInfo = "Other Information" 
 
 
 
 
// i is an abbreviation for "invalid" 
 
var iStateCode = "This field must be a valid two character U.S. state abbreviation (like CA for California). Please reenter it now." 
var iZIPCode = "This field must be a 5 or 9 digit U.S. ZIP Code (like 94043). Please reenter it now." 
var iUSPhone = "This field must be a 10 digit U.S. phone number (like 415 555 1212). Please reenter it now." 
var iWorldPhone = "This field must be a valid international phone number. Please reenter it now." 
var iSSN = "This field must be a 9 digit U.S. social security number (like 123 45 6789). Please reenter it now." 
var iEmail = "This field must be a valid email address (like foo@bar.com). Please reenter it now." 
var iCreditCardPrefix = "This is not a valid " 
var iCreditCardSuffix = " credit card number. (Click the link on this form to see a list of sample numbers.) Please reenter it now." 
var iDay = "This field must be a day number between 1 and 31.  Please reenter it now." 
var iMonth = "This field must be a month number between 1 and 12.  Please reenter it now." 
var iYear = "This field must be a 2 or 4 digit year number.  Please reenter it now." 
var iDatePrefix = "The Day, Month, and Year for " 
var iDateSuffix = " do not form a valid date.  Please reenter them now." 
 
 
 
// p is an abbreviation for "prompt" 
 
var pEntryPrompt = "Please enter a " 
var pStateCode = "2 character code (like CA)." 
var pZIPCode = "5 or 9 digit U.S. ZIP Code (like 94043)." 
var pUSPhone = "10 digit U.S. phone number (like 415 555 1212)." 
var pWorldPhone = "international phone number." 
var pSSN = "9 digit U.S. social security number (like 123 45 6789)." 
var pEmail = "valid email address (like foo@bar.com)." 
var pCreditCard = "valid credit card number." 
var pDay = "day number between 1 and 31." 
var pMonth = "month number between 1 and 12." 
var pYear = "2 or 4 digit year number." 
 
 
var defaultEmptyOK = false 
 
 
 
function makeArray(n) { 
   for (var i = 1; i <= n; i++) { 
      this[i] = 0 
   }  
   return this 
} 
 
 
 
var daysInMonth = makeArray(12); 
daysInMonth[1] = 31; 
daysInMonth[2] = 29;   // must programmatically check this 
daysInMonth[3] = 31; 
daysInMonth[4] = 30; 
daysInMonth[5] = 31; 
daysInMonth[6] = 30; 
daysInMonth[7] = 31; 
daysInMonth[8] = 31; 
daysInMonth[9] = 30; 
daysInMonth[10] = 31; 
daysInMonth[11] = 30; 
daysInMonth[12] = 31; 
 
 
 
 
// Valid U.S. Postal Codes for states, territories, armed forces, etc. 
// See http://www.usps.gov/ncsc/lookups/abbr_state.txt. 
 
var USStateCodeDelimiter = "|"; 
var USStateCodes = "AL|AK|AS|AZ|AR|CA|CO|CT|DE|DC|FM|FL|GA|GU|HI|ID|IL|IN|IA|KS|KY|LA|ME|MH|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|MP|OH|OK|OR|PW|PA|PR|RI|SC|SD|TN|TX|UT|VT|VI|VA|WA|WV|WI|WY|AE|AA|AE|AE|AP" 
 
 
 
 
// Check whether string s is empty. 
 
function isEmpty(s) 
{   return ((s == null) || (s.length == 0)) 
} 
 
 
// si esta vacia la cadena 
 
function esNombre (s) 
 
{   var i; 
    var cont; 
    var aux; 
   // alert(s); 
    if (isEmpty(s)) return false; 
    aux=s.length; 
		cont=0; 
    for (i = 0; i < s.length; i++) 
    {    
        var c = s.charAt(i); 
				if (isLetter(c)||(c == " ")||(c == ".")||(c == "/"))  
				//if (isLetter(c)||(c == " "))  
           { 
             if (c == " ") 
				        { 
								  cont++;    
					      } 
					 } 
				else 
				   return false; 
			 if (cont==aux) return false; 
    } 
    return true; 
} 
 

//Funcion que revisa si una cadena esta compuesta solo por numeros (Vero)
function sonNumeros (s) 
{   var i; 
    var aux; 

    if (isEmpty(s)) return false; 
    
		aux=s.length; 
    for (i = 0; i < s.length; i++) 
    {    
        var c = s.charAt(i); 
				
				if (c == " ") 
						return false;    

				if (!isDigit(c))  
				   return false; 
 
    } 
  
		return true; 
}  
 
 
function esNombre_Archivo (s) 
 
{   var i; 
    var cont; 
    var aux; 
   // alert(s); 
    if (isEmpty(s)) return false; 
    aux=s.length; 
		cont=0; 
    for (i = 0; i < s.length; i++) 
    {    
        var c = s.charAt(i); 
				if (isLetter(c)||(c == " ") || isAlphanumeric(c))  
				//if (isLetter(c)||(c == " "))  
           { 
             if (c == " ") 
				        { 
								  cont++;    
					      } 
					 } 
				else 
				   return false; 
			 if (cont==aux) return false; 
    } 
    return true; 
}  
 
// Returns true if string s is empty or  
// whitespace characters only. 
 
function isWhitespace (s) 
 
{   var i; 
    // Is s empty? 
		 
    if (isEmpty(s)) return true; 
//    alert("pasa"); 
    // Search through string's characters one by one 
    // until we find a non-whitespace character. 
    // When we do, return false; if we don't, return true. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character isn't whitespace. 
        var c = s.charAt(i); 
 
        if (whitespace.indexOf(c) == -1) return false; 
    } 
 
    // All characters are whitespace. 
    return true; 
} 
 
 
 
// Removes all characters which appear in string bag from string s. 
 
function stripCharsInBag (s, bag) 
 
{   var i; 
    var returnString = ""; 
 
    // Search through string's characters one by one. 
    // If character is not in bag, append to returnString. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character isn't whitespace. 
        var c = s.charAt(i); 
        if (bag.indexOf(c) == -1) returnString += c; 
    } 
 
    return returnString; 
} 
 
 
 
// Removes all characters which do NOT appear in string bag  
// from string s. 
 
function stripCharsNotInBag (s, bag) 
 
{   var i; 
    var returnString = ""; 
 
    // Search through string's characters one by one. 
    // If character is in bag, append to returnString. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character isn't whitespace. 
        var c = s.charAt(i); 
        if (bag.indexOf(c) != -1) returnString += c; 
    } 
 
    return returnString; 
} 
 
 
 
// Removes all whitespace characters from s. 
// Global variable whitespace (see above) 
// defines which characters are considered whitespace. 
 
function stripWhitespace (s) 
 
{   return stripCharsInBag (s, whitespace) 
} 
 
 

function charInString (c, s) 
{   for (i = 0; i < s.length; i++) 
    {   if (s.charAt(i) == c) return true; 
    } 
    return false 
} 
 
 
 

function stripInitialWhitespace (s) 
 
{   var i = 0; 
 
    while ((i < s.length) && charInString (s.charAt(i), whitespace)) 
       i++; 
     
    return s.substring (i, s.length); 
} 
 
 
 
 
 
 
 

function isLetter (c) 
{   return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) || 
           (c=="á") ||(c=="é") ||(c=="í") ||(c=="ó") ||(c=="ú") || 
					 (c=="Á") ||(c=="É") ||(c=="Í") ||(c=="Ó") ||(c=="Ú") || 
					 (c=="ñ") ||(c=="Ñ") ||(c==".")||(c=="_") ||(c=="-")) 
} 
 
/*function isLetterName (c) 
{   return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) || 
           (c=="á") ||(c=="é") ||(c=="í") ||(c=="ó") ||(c=="ú") || 
					 (c=="Á") ||(c=="É") ||(c=="Í") ||(c=="Ó") ||(c=="Ú") ) 
}*/ 
 
 
// Returns true if character c is a digit  
// (0 .. 9). 
 
function isDigit (c) 
{   return ((c >= "0") && (c <= "9")) 
} 
 
 
 
// Returns true if character c is a letter or digit. 
 
function isLetterOrDigit (c) 
{   return (isLetter(c) || isDigit(c)) 
} 
 
 

function isInteger (s) 
 
{   var i; 
 
    if (isEmpty(s))  
       if (isInteger.arguments.length == 1) return defaultEmptyOK; 
       else return (isInteger.arguments[1] == true); 
 
    // Search through string's characters one by one 
    // until we find a non-numeric character. 
    // When we do, return false; if we don't, return true. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character is number. 
        var c = s.charAt(i); 
 
        if (!isDigit(c)) return false; 
    } 
 
    // All characters are numbers. 
    return true; 
} 
 
 
 
 
 
 
 
function isSignedInteger (s) 
 
{   if (isEmpty(s))  
       if (isSignedInteger.arguments.length == 1) return defaultEmptyOK; 
       else return (isSignedInteger.arguments[1] == true); 
 
    else { 
        var startPos = 0; 
        var secondArg = defaultEmptyOK; 
 
        if (isSignedInteger.arguments.length > 1) 
            secondArg = isSignedInteger.arguments[1]; 
 
        // skip leading + or - 
        if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") ) 
           startPos = 1;     
        return (isInteger(s.substring(startPos, s.length), secondArg)) 
    } 
} 
 
 

function isPositiveInteger (s) 
{   var secondArg = defaultEmptyOK; 
 
    if (isPositiveInteger.arguments.length > 1) 
        secondArg = isPositiveInteger.arguments[1]; 
 
    return (isSignedInteger(s, secondArg) 
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) > 0) ) ); 
} 
 
 
 
 
 
function isNonnegativeInteger (s) 
{   var secondArg = defaultEmptyOK; 
 
    if (isNonnegativeInteger.arguments.length > 1) 
        secondArg = isNonnegativeInteger.arguments[1]; 
 
 
    return (isSignedInteger(s, secondArg) 
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) >= 0) ) ); 
} 
 
 
 
 
function isNegativeInteger (s) 
{   var secondArg = defaultEmptyOK; 
 
    if (isNegativeInteger.arguments.length > 1) 
        secondArg = isNegativeInteger.arguments[1]; 
 
 
    return (isSignedInteger(s, secondArg) 
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) < 0) ) ); 
} 
 
 
 
 
 
 
 
function isNonpositiveInteger (s) 
{   var secondArg = defaultEmptyOK; 
 
    if (isNonpositiveInteger.arguments.length > 1) 
        secondArg = isNonpositiveInteger.arguments[1]; 
 
    return (isSignedInteger(s, secondArg) 
         && ( (isEmpty(s) && secondArg)  || (parseInt (s) <= 0) ) ); 
} 
 
 
 
 
 
 
function isFloat (s) 
 
{   var i; 
    var seenDecimalPoint = false; 
 
    if (isEmpty(s))  
       if (isFloat.arguments.length == 1) return defaultEmptyOK; 
       else return (isFloat.arguments[1] == true); 
 
    if (s == decimalPointDelimiter) return false; 
 
    // Search through string's characters one by one 
    // until we find a non-numeric character. 
    // When we do, return false; if we don't, return true. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character is number. 
        var c = s.charAt(i); 
 
        if ((c == decimalPointDelimiter) && !seenDecimalPoint) seenDecimalPoint = true; 
        else if (!isDigit(c)) return false; 
    } 
 
    // All characters are numbers. 
    return true; 
} 
 
 
 
 
 
 
 
// isSignedFloat (STRING s [, BOOLEAN emptyOK]) 
//  
// True if string s is a signed or unsigned floating point  
// (real) number. First character is allowed to be + or -. 
// 
// Also returns true for unsigned integers. If you wish 
// to distinguish between integers and floating point numbers, 
// first call isSignedInteger, then call isSignedFloat. 
// 
// Does not accept exponential notation. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
 
function isSignedFloat (s) 
 
{   if (isEmpty(s))  
       if (isSignedFloat.arguments.length == 1) return defaultEmptyOK; 
       else return (isSignedFloat.arguments[1] == true); 
 
    else { 
        var startPos = 0; 
        var secondArg = defaultEmptyOK; 
 
        if (isSignedFloat.arguments.length > 1) 
            secondArg = isSignedFloat.arguments[1]; 
 
        // skip leading + or - 
        if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") ) 
           startPos = 1;     
        return (isFloat(s.substring(startPos, s.length), secondArg)) 
    } 
} 
 
 
 
 
// isAlphabetic (STRING s [, BOOLEAN emptyOK]) 
//  
// Returns true if string s is English letters  
// (A .. Z, a..z) only. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
// 
// NOTE: Need i18n version to support European characters. 
// This could be tricky due to different character 
// sets and orderings for various languages and platforms. 
 
function isAlphabetic (s) 
 
{   var i; 
 
    if (isEmpty(s))  
       if (isAlphabetic.arguments.length == 1) return defaultEmptyOK; 
       else return (isAlphabetic.arguments[1] == true); 
 
    // Search through string's characters one by one 
    // until we find a non-alphabetic character. 
    // When we do, return false; if we don't, return true. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character is letter. 
        var c = s.charAt(i); 
 
        if (!isLetter(c)) 
        return false; 
    } 
 
    // All characters are letters. 
    return true; 
} 
/* 
function isName (s) 
 
{   var i; 
 
    if (isEmpty(s))  
       if (isName.arguments.length == 1) return defaultEmptyOK; 
       else return (isName.arguments[1] == true); 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character is letter. 
        var c = s.charAt(i); 
 
        if (!isLetterName(c)) 
        return false; 
    } 
 
    // All characters are letters. 
    return true; 
}*/ 
 
 
 
 
// isAlphanumeric (STRING s [, BOOLEAN emptyOK]) 
//  
// Returns true if string s is English letters  
// (A .. Z, a..z) and numbers only. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
// 
// NOTE: Need i18n version to support European characters. 
// This could be tricky due to different character 
// sets and orderings for various languages and platforms. 
 
function isAlphanumeric (s) 
 
{   var i; 
 
    if (isEmpty(s))  
       if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK; 
       else return (isAlphanumeric.arguments[1] == true); 
 
    // Search through string's characters one by one 
    // until we find a non-alphanumeric character. 
    // When we do, return false; if we don't, return true. 
 
    for (i = 0; i < s.length; i++) 
    {    
        // Check that current character is number or letter. 
        var c = s.charAt(i); 
 
        if (! (isLetter(c) || isDigit(c) ) ) 
        return false; 
    } 
 
    // All characters are numbers or letters. 
    return true; 
} 
 
 
 
 
function reformat (s) 
 
{   var arg; 
    var sPos = 0; 
    var resultString = ""; 
 
    for (var i = 1; i < reformat.arguments.length; i++) { 
       arg = reformat.arguments[i]; 
       if (i % 2 == 1) resultString += arg; 
       else { 
           resultString += s.substring(sPos, sPos + arg); 
           sPos += arg; 
       } 
    } 
    return resultString; 
} 
 
 
 
function isSSN (s) 
{   if (isEmpty(s))  
       if (isSSN.arguments.length == 1) return defaultEmptyOK; 
       else return (isSSN.arguments[1] == true); 
    return (isInteger(s) && s.length == digitsInSocialSecurityNumber) 
} 
 
 
function isInternationalPhoneNumber (s) 
{   if (isEmpty(s))  
       if (isInternationalPhoneNumber.arguments.length == 1) return defaultEmptyOK; 
       else return (isInternationalPhoneNumber.arguments[1] == true); 
    return (isPositiveInteger(s)) 
} 
 
 
function isEmail (s) 
{   
   if (isEmpty(s))  
       if (isEmail.arguments.length == 1) return defaultEmptyOK; 
       else return (isEmail.arguments[1] == true); 
    
    // is s whitespace? 
    if (isWhitespace(s)) return false; 
   // if (isWhitespace(s)) return true; 
    // there must be >= 1 character before @, so we 
    // start looking at character position 1  
    // (i.e. second character) 
    var i = 1; 
    var sLength = s.length; 
 
    // look for @ 
    while ((i < sLength) && (s.charAt(i) != "@")) 
    { i++ 
    } 
 
    if ((i >= sLength) || (s.charAt(i) != "@")) return false; 
    else i += 2; 
 
    // look for . 
    while ((i < sLength) && (s.charAt(i) != ".")) 
    { i++ 
    } 
 
    // there must be at least one character after the . 
    if ((i >= sLength - 1) || (s.charAt(i) != ".")) return false; 
    else return true; 
} 
 
 
function isYear (s) 
{   if (isEmpty(s))  
       if (isYear.arguments.length == 1) return defaultEmptyOK; 
       else return (isYear.arguments[1] == true); 
    if (!isNonnegativeInteger(s)) return false; 
    return (s.length == 4); 
} 
 
 
 
function isIntegerInRange (s, a, b) 
{   if (isEmpty(s))  
       if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK; 
       else return (isIntegerInRange.arguments[1] == true); 
 
    // Catch non-integer strings to avoid creating a NaN below, 
    // which isn't available on JavaScript 1.0 for Windows. 
    if (!isInteger(s, false)) return false; 
 
    // Now, explicitly change the type to integer via parseInt 
    // so that the comparison code below will work both on  
    // JavaScript 1.2 (which typechecks in equality comparisons) 
    // and JavaScript 1.1 and before (which doesn't). 
    var num = parseInt (s); 
    return ((num >= a) && (num <= b)); 
} 
 
 
 
 
function isMonth (s) 
{   if (isEmpty(s))  
       if (isMonth.arguments.length == 1) return defaultEmptyOK; 
       else return (isMonth.arguments[1] == true); 
    return isIntegerInRange (s, 1, 12); 
} 
 
function isDay (s) 
{   if (isEmpty(s))  
       if (isDay.arguments.length == 1) return defaultEmptyOK; 
       else return (isDay.arguments[1] == true);    
    return isIntegerInRange (s, 1, 31); 
} 
 
 
 
function daysInFebruary (year) 
{   // February has 29 days in any year evenly divisible by four, 
    // EXCEPT for centurial years which are not also divisible by 400. 
    return (  ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 ); 
} 
 
 
 
 
function isDate (year, month, day) 
{   // catch invalid years (not 2- or 4-digit) and invalid months and days. 
    if (! (isYear(year, false) && isMonth(month, false) && isDay(day, false))) return false; 
 
    // Explicitly change type to integer to make code work in both 
    // JavaScript 1.1 and JavaScript 1.2. 
    var intYear = parseInt(year); 
    var intMonth = parseInt(month); 
    var intDay = parseInt(day); 
 
    // catch invalid days, except for February 
    if (intDay > daysInMonth[intMonth]) return false;  
 
    if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) return false; 
 
    return true; 
} 
 
 
 
 
/* FUNCTIONS TO NOTIFY USER OF INPUT REQUIREMENTS OR MISTAKES. */ 
 
 
// Display prompt string s in status bar. 
 
function prompt (s) 
{   window.status = s 
} 
 
 
 
// Display data entry prompt string s in status bar. 
 
function promptEntry (s) 
{   window.status = pEntryPrompt + s 
} 
 
 
 
 
// Notify user that required field theField is empty. 
// String s describes expected contents of theField.value. 
// Put focus in theField and return false. 
 
function warnEmpty (theField, s) 
{   theField.focus() 
    alert(mPrefix + s + mSuffix) 
    return false 
} 
 
 
 
// Notify user that contents of field theField are invalid. 
// String s describes expected contents of theField.value. 
// Put select theField, pu focus in it, and return false. 
 
function warnInvalid (theField, s) 
{   theField.focus() 
    theField.select() 
    alert(s) 
    return false 
} 
 
 

function checkString (theField, s, emptyOK) 
{   // Next line is needed on NN3 to avoid "undefined is not a number" error 
    // in equality comparison below. 
    if (checkString.arguments.length == 2) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    if (isWhitespace(theField.value))  
       return warnEmpty (theField, s); 
    else return true; 
} 
 
 
function checkStateCode (theField, emptyOK) 
{   if (checkStateCode.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    else 
    {  theField.value = theField.value.toUpperCase(); 
       if (!isStateCode(theField.value, false))  
          return warnInvalid (theField, iStateCode); 
       else return true; 
    } 
} 
 
 
 

 
 
function checkInternationalPhone (theField, emptyOK) 
{   if (checkInternationalPhone.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    else 
    {  if (!isInternationalPhoneNumber(theField.value, false))  
          return warnInvalid (theField, iWorldPhone); 
       else return true; 
    } 
} 
 
 
 
function checkEmail (theField, emptyOK) 
{   if (checkEmail.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    else if (!isEmail(theField.value, false))  
       return warnInvalid (theField, iEmail); 
    else return true; 
} 
 
 
 
function reformatSSN (SSN) 
{   return (reformat (SSN, "", 3, "-", 2, "-", 4)) 
} 
 
 
 
function checkSSN (theField, emptyOK) 
{   if (checkSSN.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    else 
    {  var normalizedSSN = stripCharsInBag(theField.value, SSNDelimiters) 
       if (!isSSN(normalizedSSN, false))  
          return warnInvalid (theField, iSSN); 
       else  
       {  // if you don't want to reformats as 123-456-7890, comment next line out 
          theField.value = reformatSSN(normalizedSSN) 
          return true; 
       } 
    } 
} 
 
 
 
 
// Check that string theField.value is a valid Year. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
 
function checkYear (theField, emptyOK) 
{   if (checkYear.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    if (!isYear(theField.value, false))  
       return warnInvalid (theField, iYear); 
    else return true; 
} 
 
 
// Check that string theField.value is a valid Month. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
 
function checkMonth (theField, emptyOK) 
{   if (checkMonth.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    if (!isMonth(theField.value, false))  
       return warnInvalid (theField, iMonth); 
    else return true; 
} 
 
 
// Check that string theField.value is a valid Day. 
// 
// For explanation of optional argument emptyOK, 
// see comments of function isInteger. 
 
function checkDay (theField, emptyOK) 
{   if (checkDay.arguments.length == 1) emptyOK = defaultEmptyOK; 
    if ((emptyOK == true) && (isEmpty(theField.value))) return true; 
    if (!isDay(theField.value, false))  
       return warnInvalid (theField, iDay); 
    else return true; 
} 
 
 

function checkDate (yearField, monthField, dayField, labelString, OKtoOmitDay) 
{   // Next line is needed on NN3 to avoid "undefined is not a number" error 
    // in equality comparison below. 
    if (checkDate.arguments.length == 4) OKtoOmitDay = false; 
    if (!isYear(yearField.value)) return warnInvalid (yearField, iYear); 
    if (!isMonth(monthField.value)) return warnInvalid (monthField, iMonth); 
    if ( (OKtoOmitDay == true) && isEmpty(dayField.value) ) return true; 
    else if (!isDay(dayField.value))  
       return warnInvalid (dayField, iDay); 
    if (isDate (yearField.value, monthField.value, dayField.value)) 
       return true; 
    alert (iDatePrefix + labelString + iDateSuffix) 
    return false 
} 
 
 
 
// Get checked value from radio button. 
 
function getRadioButtonValue (radio) 
{   for (var i = 0; i < radio.length; i++) 
    {   if (radio[i].checked) { break } 
    } 
    return radio[i].value 
} 
 
 
 
 
// Validate credit card info. 
 
function checkCreditCard (radio, theField) 
{   var cardType = getRadioButtonValue (radio) 
    var normalizedCCN = stripCharsInBag(theField.value, creditCardDelimiters) 
    if (!isCardMatch(cardType, normalizedCCN))  
       return warnInvalid (theField, iCreditCardPrefix + cardType + iCreditCardSuffix); 
    else  
    {  theField.value = normalizedCCN 
       return true 
    } 
} 
 
 

function isCreditCard(st) { 
  // Encoding only works on cards with less than 19 digits 
  if (st.length > 19) 
    return (false); 
 
  sum = 0; mul = 1; l = st.length; 
  for (i = 0; i < l; i++) { 
    digit = st.substring(l-i-1,l-i); 
    tproduct = parseInt(digit ,10)*mul; 
    if (tproduct >= 10) 
      sum += (tproduct % 10) + 1; 
    else 
      sum += tproduct; 
    if (mul == 1) 
      mul++; 
    else 
      mul--; 
  } 
  if ((sum % 10) == 0) 
    return (true); 
  else 
    return (false); 
 
} // END FUNCTION isCreditCard() 
 
function isVisa(cc) 
{ 
  if (((cc.length == 16) || (cc.length == 13)) && 
      (cc.substring(0,1) == 4)) 
    return isCreditCard(cc); 
  return false; 
}  // END FUNCTION isVisa() 
 
 
 
 
 
function isMasterCard(cc) 
{ 
  firstdig = cc.substring(0,1); 
  seconddig = cc.substring(1,2); 
  if ((cc.length == 16) && (firstdig == 5) && 
      ((seconddig >= 1) && (seconddig <= 5))) 
    return isCreditCard(cc); 
  return false; 
 
} // END FUNCTION isMasterCard() 
 
 
 
 
 
function isAmericanExpress(cc) 
{ 
  firstdig = cc.substring(0,1); 
  seconddig = cc.substring(1,2); 
  if ((cc.length == 15) && (firstdig == 3) && 
      ((seconddig == 4) || (seconddig == 7))) 
    return isCreditCard(cc); 
  return false; 
 
} // END FUNCTION isAmericanExpress() 
 
 
 
 
function isDinersClub(cc) 
{ 
  firstdig = cc.substring(0,1); 
  seconddig = cc.substring(1,2); 
  if ((cc.length == 14) && (firstdig == 3) && 
      ((seconddig == 0) || (seconddig == 6) || (seconddig == 8))) 
    return isCreditCard(cc); 
  return false; 
} 
 
 
 
function isCarteBlanche(cc) 
{ 
  return isDinersClub(cc); 
} 
 
 
 
 
function isDiscover(cc) 
{ 
  first4digs = cc.substring(0,4); 
  if ((cc.length == 16) && (first4digs == "6011")) 
    return isCreditCard(cc); 
  return false; 
 
} // END FUNCTION isDiscover() 
 
 
 
 
function isEnRoute(cc) 
{ 
  first4digs = cc.substring(0,4); 
  if ((cc.length == 15) && 
      ((first4digs == "2014") || 
       (first4digs == "2149"))) 
    return isCreditCard(cc); 
  return false; 
} 
 
function isJCB(cc) 
{ 
  first4digs = cc.substring(0,4); 
  if ((cc.length == 16) && 
      ((first4digs == "3088") || 
       (first4digs == "3096") || 
       (first4digs == "3112") || 
       (first4digs == "3158") || 
       (first4digs == "3337") || 
       (first4digs == "3528"))) 
    return isCreditCard(cc); 
  return false; 
 
} // END FUNCTION isJCB() 
 
 
 
function isAnyCard(cc) 
{ 
  if (!isCreditCard(cc)) 
    return false; 
  if (!isMasterCard(cc) && !isVisa(cc) && !isAmericanExpress(cc) && !isDinersClub(cc) && 
      !isDiscover(cc) && !isEnRoute(cc) && !isJCB(cc)) { 
    return false; 
  } 
  return true; 
 
} // END FUNCTION isAnyCard() 
 
 
 
function isCardMatch (cardType, cardNumber) 
{ 
 
	cardType = cardType.toUpperCase(); 
	var doesMatch = true; 
 
	if ((cardType == "VISA") && (!isVisa(cardNumber))) 
		doesMatch = false; 
	if ((cardType == "MASTERCARD") && (!isMasterCard(cardNumber))) 
		doesMatch = false; 
	if ( ( (cardType == "AMERICANEXPRESS") || (cardType == "AMEX") ) 
                && (!isAmericanExpress(cardNumber))) doesMatch = false; 
	if ((cardType == "DISCOVER") && (!isDiscover(cardNumber))) 
		doesMatch = false; 
	if ((cardType == "JCB") && (!isJCB(cardNumber))) 
		doesMatch = false; 
	if ((cardType == "DINERS") && (!isDinersClub(cardNumber))) 
		doesMatch = false; 
	if ((cardType == "CARTEBLANCHE") && (!isCarteBlanche(cardNumber))) 
		doesMatch = false; 
	if ((cardType == "ENROUTE") && (!isEnRoute(cardNumber))) 
		doesMatch = false; 
	return doesMatch; 
 
}  // END FUNCTION CardMatch() 
 
 
 
 
 
function IsCC (st) { 
    return isCreditCard(st); 
} 
 
function IsVisa (cc)  { 
  return isVisa(cc); 
} 
 
function IsVISA (cc)  { 
  return isVisa(cc); 
} 
 
function IsMasterCard (cc)  { 
  return isMasterCard(cc); 
} 
 
function IsMastercard (cc)  { 
  return isMasterCard(cc); 
} 
 
function IsMC (cc)  { 
  return isMasterCard(cc); 
} 
 
function IsAmericanExpress (cc)  { 
  return isAmericanExpress(cc); 
} 
 
function IsAmEx (cc)  { 
  return isAmericanExpress(cc); 
} 
 
function IsDinersClub (cc)  { 
  return isDinersClub(cc); 
} 
 
function IsDC (cc)  { 
  return isDinersClub(cc); 
} 
 
function IsDiners (cc)  { 
  return isDinersClub(cc); 
} 
 
function IsCarteBlanche (cc)  { 
  return isCarteBlanche(cc); 
} 
 
function IsCB (cc)  { 
  return isCarteBlanche(cc); 
} 
 
function IsDiscover (cc)  { 
  return isDiscover(cc); 
} 
 
function IsEnRoute (cc)  { 
  return isEnRoute(cc); 
} 
 
function IsenRoute (cc)  { 
  return isEnRoute(cc); 
} 
 
function IsJCB (cc)  { 
  return isJCB(cc); 
} 
 
function IsAnyCard(cc)  { 
  return isAnyCard(cc); 
} 
 
function IsCardMatch (cardType, cardNumber)  { 
  return isCardMatch (cardType, cardNumber); 
} 
 
   function pon_comas(cant) 
	    { 
//			 alert(cant); 
		   var len,cont,ent,dec,car; 
	     ent=""; 
	     dec=""; 
	     cont=0; 
       cant=cant+""; 
		   len=cant.length; 
			 Punto=0; 
		   for (r=len-1;r>=0;r--) 
		       { 
             cont++; 
			       car=cant.charAt(r); 
             if (car==".") 
                { 
								  Punto=1; 
                  cont=0; 
                }   
						 if (Punto==0) { dec=car+dec; } 
			     } 
			 if (Punto==0) {dec=""}; 
       ent=cant.substr(0,cont); 
			 len2=ent.length; 
			 if (len2>3) 
			    { 
			      aux1=cant.substr(len2-3,3); 
			      aux2=cant.substr(0,len2-3); 
			  	  canfin=aux2+","+aux1; 
				  } 
	     else 
			    { 
				    canfin=ent; 
				  } 
			 if (Punto==1){canfin=canfin+"."+dec;} 
			 return canfin; 
    } 
     
    function quita_comas(cant) 
       { 
         var len,car,canfin; 
         canfin=""; 
				 //alert(cant); 
				 cant=cant+""; 
         //cant=document.forma.cantidad.value; 
		     len=cant.length; 
				 //alert(len); 
		     for (r=0;r<len;r++) 
		         { 
			         car=cant.charAt(r); 
			         if (car!=",") 
			            { 
			              canfin=canfin+car; 
			            } 
			       } 
			  //document.forma.fin.value=canfin; 
				return canfin; 
       }