// JSript functions shared across multiple ActiveDocs Pages

// Get query string from URL START
function queryString(key) {
    var page = new PageQuery(window.location.search);
    return unescape(page.getValue(key));
}

function PageQuery(q) {
    if (q.length > 1) this.q = q.substring(1, q.length);
    else this.q = null;
    this.keyValuePairs = new Array();
    if (q) {
        for (var i = 0; i < this.q.split("&").length; i++) {
            this.keyValuePairs[i] = this.q.split("&")[i];
        }
    }
    this.getKeyValuePairs = function () { return this.keyValuePairs; }
    this.getValue = function (s) {
        for (var j = 0; j < this.keyValuePairs.length; j++) {
            if (this.keyValuePairs[j].split("=")[0] == s)
                return this.keyValuePairs[j].split("=")[1];
        }
        return false;
    }
    this.getParameters = function () {
        var a = new Array(this.getLength());
        for (var j = 0; j < this.keyValuePairs.length; j++) {
            a[j] = this.keyValuePairs[j].split("=")[0];
        }
        return a;
    }
    this.getLength = function () { return this.keyValuePairs.length; }
}
// Get query string from URL END

//Swap btnOK with the disabled btnOKSubmitted so that double postbacks can be avoided
function SubmitHide(controlID1,controlID2)
{
    var hideSubmit = document.getElementById(controlID1);
    hideSubmit.style.visibility = 'hidden';

    var hideSubmit = document.getElementById(controlID2);
    hideSubmit.style.visibility = 'visible';
}

function doHourglass()
{
    document.body.style.cursor = 'wait';
}

//This sets the mousepointer to hourglass on postback
function setcursorhourglass() {
    try {
        for (var loop = 0; loop < document.all.length; ++loop) {
            sTagName = document.all[loop].tagName;
            if (sTagName == 'A') { document.all[loop].style.cursor = 'wait'; }
            if (sTagName == 'INPUT') { document.all[loop].style.cursor = 'wait'; }
        }
    }
    catch (e) { }
    finally { }
}

//Editable Combo Functions

/*
    Dropdown specific global variables are:
    1) vEditableOptionIndex_A   --> this needs to be set by Programmer!! See explanation.
    2) vEditableOptionText_A    --> this needs to be set by Programmer!! See explanation.
    3) vPreviousSelectIndex_A
    4) vSelectIndex_A
    5) vSelectChange_A

  The dropdown specific functions (which manipulate dropdown specific global variables)
  used by all dropdowns are:

  1) function EditableComboChangeHandler_A(getdropdown)
  2) function EditableComboKeyPressHandler_A(getdropdown, e)
  3) function EditableComboKeyUpHandler_A(getdropdown, e)

*/

  var vEditableOptionIndex_A = 0;

  // Give Index of Editable option in the dropdown. eg:
  // if first option is editable then vEditableOptionIndex_A = 0;
  // if second option is editable then vEditableOptionIndex_A = 1;
  // if last option is editable then vEditableOptionIndex_A = (length of dropdown - 1).

  var vEditableOptionText_A = "(select or type a value)";

  // Give the default text of the Editable option in the dropdown. eg:
  // if the editable option is <option ...><(type a value)</option>,
  // then set vEditableOptionText_A = "(type a value)";

  //Global Variables required for
  //EditableComboChangeHandler_A(), EditableComboKeyPressHandler_A() and EditableComboKeyUpHandler_A()
  //for Editable Dropdowns
  
  var vPreviousSelectIndex_A = 0;
  // Contains the Previously Selected Index, set to 0 by default

  var vSelectIndex_A = 0;
  // Contains the Currently Selected Index, set to 0 by default

  var vSelectChange_A = 'MANUAL_CLICK';
  // Indicates whether Change in dropdown selected option was due to a Manual Click or due to System properties of dropdown.
  
  // vSelectChange_A = 'MANUAL_CLICK' indicates that the jump to a non-editable option in the dropdown was due
  // to a Manual click (i.e.,changed on purpose by user).

  // vSelectChange_A = 'AUTO_SYSTEM' indicates that the jump to a non-editable option was due to System properties of dropdown
  // (i.e.,user did not change the option in the dropdown; instead an automatic jump happened due to inbuilt
  // dropdown properties of browser on typing of a character)

  function EditableComboSetResource(defaultText) 
  {
      vEditableOptionText_A = defaultText;
  }

  function EditableComboChangeHandler_A(getdropdown)
  {
    EditableComboSanityCheck(getdropdown);

    vPreviousSelectIndex_A = vSelectIndex_A;  // Contains the Previously Selected Index

    vSelectIndex_A = getdropdown.options.selectedIndex;  // Contains the Currently Selected Index

    if ((vPreviousSelectIndex_A == (vEditableOptionIndex_A)) && (vSelectIndex_A != (vEditableOptionIndex_A))&&(vSelectChange_A != 'MANUAL_CLICK'))
    // To Set value of Index variables 
    {
      getdropdown[(vEditableOptionIndex_A)].selected=true;
      vPreviousSelectIndex_A = vSelectIndex_A;
      vSelectIndex_A = getdropdown.options.selectedIndex;
      vSelectChange_A = 'MANUAL_CLICK';

      var hiddentext = document.getElementById('hiddenvalue_' + getdropdown.id);
      hiddentext.value = getdropdown.options.selected.text;  // Indicates that the Change in dropdown selected option was due to a Manual Click
    }
  }

  function EditableComboKeyPressHandler_A(getdropdown, e)
  {
    EditableComboSanityCheck(getdropdown);

    keycode = FindKeyCode(e);
    keychar = FindKeyChar(e);

    // Check for allowable Characters. The various characters allowable for entry into Editable option..
    // may be customized by minor modifications in the code (if condition below)
    // (you need to know the keycode/ASCII value of the  character to be allowed/disallowed).

    if ((keycode>31 && keycode<59)||(keycode>62)) // && keycode<127))
    {
      var vAllowableCharacter = "yes";
    }
    else
    {
      var vAllowableCharacter = "no";
    }

    //alert(window); alert(window.event);

    if(getdropdown.options.length != 0)
    // if dropdown is not empty
      if (getdropdown.options.selectedIndex == (vEditableOptionIndex_A))
      // if selected option the Editable option of the dropdown
      {

        var vEditString = getdropdown[vEditableOptionIndex_A].value;

        // make Editable option Null if it is being edited for the first time
        if((vAllowableCharacter == "yes")||(keychar=="backspace"))
        {
          if (vEditString == vEditableOptionText_A)
            vEditString = "";
        }
        if (keychar=="backspace")
        // To handle backspace
        {
          vEditString = vEditString.substring(0,vEditString.length-1);
          // Decrease length of string by one from right

          vSelectChange_A = 'MANUAL_CLICK';
          // Indicates that the Change in dropdown selected option was due to a Manual Click

        }
        //alert("EditString2:"+vEditString);

        if (vAllowableCharacter == "yes")
        // To handle addition of a character - Subrata Chakrabarty
        {
          vEditString+=String.fromCharCode(keycode);
          // Concatenate Enter character to Editable string
          // The following portion handles the "automatic Jump" bug. The "automatic Jump" bug (Description):
          //   If a alphabet is entered (while editing)
          //   ...which is contained as a first character in one of the read-only options
          //   ..the focus automatically "jumps" to the read-only option
          //   (-- this is a common property of normal dropdowns ..but..is undesirable while editing).

          var i=0;
          var vEnteredChar = String.fromCharCode(keycode);
          var vUpperCaseEnteredChar = vEnteredChar;
          var vLowerCaseEnteredChar = vEnteredChar;


          if(((keycode)>=97)&&((keycode)<=122))
          // if vEnteredChar lowercase
            vUpperCaseEnteredChar = String.fromCharCode(keycode - 32);
            // This is UpperCase


          if(((keycode)>=65)&&((keycode)<=90))
          // if vEnteredChar is UpperCase
            vLowerCaseEnteredChar = String.fromCharCode(keycode + 32);
            // This is lowercase

          if(e.which) //For Netscape
          {
            // Compare the typed character (into the editable option) with the first character of all the other options (non-editable).
            // To note if the jump to the non-editable option was due to a Manual click (i.e.,changed on purpose by user)
            // or due to System properties of dropdown (i.e.,user did not change the option in the dropdown; instead an automatic jump 
            // happened due to inbuilt dropdown properties of browser on typing of a character)

            for (i=0;i<=(getdropdown.options.length-1);i++)
            {
              if(i!=vEditableOptionIndex_A)
              {
                var vReadOnlyString = getdropdown[i].value;
                var vFirstChar = vReadOnlyString.substring(0,1);
                if((vFirstChar == vUpperCaseEnteredChar)||(vFirstChar == vLowerCaseEnteredChar))
                {
                  vSelectChange_A = 'AUTO_SYSTEM';
                  // Indicates that the Change in dropdown selected
                  // option was due to System properties of dropdown
                  break;
                }
                else
                {
                  vSelectChange_A = 'MANUAL_CLICK';
                  // Indicates that the Change in dropdown selected
                  // option was due to a Manual Click
                }
              }
            }
          }
        }

        // Set the new edited string into the Editable option
        getdropdown.options[vEditableOptionIndex_A].text = vEditString;
        getdropdown.options[vEditableOptionIndex_A].value = vEditString;
        var hiddentext = document.getElementById('hiddenvalue_' + getdropdown.id);
        hiddentext.value = vEditString;
        return false;
      }
    return true;
  }

  function EditableComboKeyUpHandler_A(getdropdown, e)
  {
    EditableComboSanityCheck(getdropdown);

    if(e.which) // Netscape
    {
      if(vSelectChange_A == 'AUTO_SYSTEM')
      {
        // if editable dropdown option jumped while editing
        // (due to typing of a character which is the first character of some other option)
        // then go back to the editable option.
        getdropdown[(vEditableOptionIndex_A)].selected=true;
      }

      var vEventKeyCode = FindKeyCode(e);
      // if [ <- ] or [ -> ] arrow keys are pressed, select the editable option
      if((vEventKeyCode == 37)||(vEventKeyCode == 39))
      {
          getdropdown[vEditableOptionIndex_A].selected = true;
          var hiddentext = document.getElementById('hiddenvalue_' + getdropdown.id);
          hiddentext.value = getdropdown.options[vEditableOptionIndex_A].text;
      }
    }
}

function EditableComboKeyDownHandler(getdropdown, e) {
    EditableComboSanityCheck(getdropdown);

    // Press [ <- ] and [ -> ] arrow keys on the keyboard to change alignment/flow.
    // ...go to Start : Press  [ <- ] Arrow Key
    // ...go to End : Press [ -> ] Arrow Key
    // (this is useful when the edited-text content exceeds the ListBox-fixed-width)
    // This works best on Internet Explorer, and not on Netscape

    var vEventKeyCode = FindKeyCode(e);

    // Press left/right arrow keys
    if (vEventKeyCode == 37) {
        EditableComboLeftToRight(getdropdown);
    }
    if (vEventKeyCode == 39) {
        EditableComboRightToLeft(getdropdown);
    }

    // Delete key pressed
    if (vEventKeyCode == 46) {
        EditableComboDelete(getdropdown);
    }

    // backspace key pressed
    if (vEventKeyCode == 8 || vEventKeyCode == 127) {
        if (e.which) //Netscape
        {
            //e.which = ''; //this property has only a getter.
        }
        else //Internet Explorer
        {
            //To prevent backspace from activating the -Back- button of the browser
            e.keyCode = '';
            if (window.event.keyCode) {
                window.event.keyCode = '';
            }
        }
        return true;
    }

    // Tab key pressed, use code below to reorient to Left-To-Right flow, if needed
    //if(vEventKeyCode == 9)
    //{
    //  EditableComboLeftToRight(getdropdown);
    //}
}

function EditableComboLeftToRight(getdropdown) {
    getdropdown.style.direction = "ltr";
}

function EditableComboRightToLeft(getdropdown) {
    getdropdown.style.direction = "rtl";
}

function EditableComboDelete(getdropdown) {
    if (getdropdown.options.length != 0)
    // if dropdown is not empty
    {
        if (getdropdown.options.selectedIndex == vEditableOptionIndex_A)
        // if option the Editable field
        {
            getdropdown.options[getdropdown.options.selectedIndex].text = vEditableOptionText_A;
            getdropdown.options[getdropdown.options.selectedIndex].value = vEditableOptionText_A;
            var hiddentext = document.getElementById('hiddenvalue_' + getdropdown.id);
            hiddentext.value = '';
        }
    }
}


/*
Since Internet Explorer and Netscape have different ways of returning the key code, displaying keys
browser-independently is a bit harder. However, you can create a script that displays keys for either browser.
The following function will display each key in the status line:

The "FindKey.." function receives the "event" object from the event handler and stores it in the variable "e".
It checks whether the "e.which" property exists (for Netscape), and stores it in the "keycode" variable if present.
Otherwise, it assumes the browser is Internet Explorer and assigns to keycode the "e.keyCode" property.
*/

function FindKeyCode(e) {
    if (e.which) {
        keycode = e.which;  //Netscape
    }
    else {
        keycode = e.keyCode; //Internet Explorer
    }

    //alert("FindKeyCode"+ keycode);
    return keycode;
}

function FindKeyChar(e) {
    keycode = FindKeyCode(e);
    if ((keycode == 8) || (keycode == 127)) {
        character = "backspace"
    }
    else if ((keycode == 46)) {
        character = "delete"
    }
    else {
        character = String.fromCharCode(keycode);
    }
    //alert("FindKey"+ character);
    return character;
}

function EditableComboSanityCheck(getdropdown) {
    if (vEditableOptionIndex_A > (getdropdown.options.length - 1)) {
        alert("ERROR: The value of variable vEditableOptionIndex_... cannot be greater than (length of dropdown - 1)");
        return false;
    }
}

//EditableCombo Functions end

//Forces On Step Calculation Post Back
function OnstepCalcPostback(e, sCalcButtonID, sEventArg)
{

    if(e.which || e.keyCode)
    {
        if (((e.which == 9) || (e.keyCode == 9)) && e.shiftKey == false)
        {
            javascript:__doPostBack(sCalcButtonID,sEventArg);
            return false;
        }
        return true;
    }
    return false;         
}

//Auto post back OK on Enter, works for all browsers
function AutoOK(e, sOKButtonID)
{
    if(e.which || e.keyCode)
    {
        if ((e.which == 13) || (e.keyCode == 13)) 
        {
            var cntOKBtn = document.getElementById(sOKButtonID)
            cntOKBtn.target = '';
            cntOKBtn.focus();
            // attempt 1
            try
            {
                if (cntOKBtn.click())
                {
                    return true;
                }
            }
            catch(e)
            { 
                // attempt 2
                if (document.createEvent)
                {
                    var evtObj = document.createEvent('MouseEvents');
                    if (evtObj && cntOKBtn.dispatchEvent && evtObj.initMouseEvent)
                    {
                        evtObj.initMouseEvent('click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
                        return cntOKBtn.dispatchEvent(evtObj);
                    }
                }
                    else
                        if (document.createEventObject)
                        {
                            return cntOKBtn.fireEvent('onclick');
                        }
                
                // attempt 3
                if (cntOKBtn.href)
                {
                    location = cntOKBtn.href;
                    return true;
                }
                return false;
            }
        } 
        else 
        {
            return true;
        }
    }
}

//Hides shows text box for edit combo functionality
function EnableEditComboControl(sID)
{
     var cntCombo = document.getElementById(sID);
     var cntCheckBox = document.getElementById(sID + '_chk');
     var cntTextBox = document.getElementById(sID + '_txt');
     var cntLabel = document.getElementById(sID + '_lbl');
     var cntCheckLabel = document.getElementById(sID + '_lbl1');
     var cntUncheckLabel = document.getElementById(sID + '_lbl2');
     
     if(cntCombo != null)
     {
        if(cntCheckBox.checked)
        {
            cntTextBox.style.visibility  = 'visible';
            cntTextBox.style.display = 'block';
            cntCombo.style.visibility = 'hidden';
            cntCombo.style.display= 'none';
            cntLabel.innerText = cntUncheckLabel.innerText;
        }
        else
        {
            cntTextBox.style.visibility = 'hidden';
            cntTextBox.style.display= 'none';
            cntCombo.style.visibility  = 'visible';
            cntCombo.style.display = 'block';
            cntLabel.innerText  = cntCheckLabel.innerText;
        }
     }
}

//This is used as a workaround to fix an issue where checkbox (yes/No) 
//click events can no longer call VB script functions
function UpdateAFValueJS(iIndexOnPage, sName, sID, iDataType, vValue)
{
    UpdateAFValue(iIndexOnPage, sName, sID, iDataType, vValue);
}

//Used to dismiss an Ajax Popup and cancel the Postback
function DismissModalPopup(CancelControlID)
{
    
    $get(CancelControlID).click()
    return false;
}

//updatetip updates the tipcontrol with the tip text when a control receives focus
function updatetip(sTIPID)
{
    var sTIP = '';
    try
    { 
        var control = document.getElementById(sTIPID);
        var controlerr = document.getElementById('hiddenError'); 
        
        if( controlerr != null )
        { 
            
            if( controlerr.value != '' ) 
            { 
                return; 
            } 
        } 
        
        if( control != null ) 
        { 
            sTIP = control.value; 
            //alert('hello ' + sTIP);
        }
        var Tipcontrol = document.getElementById('ActiveDocsTipControl');
        if (Tipcontrol != null) {
            Tipcontrol.innerHTML = sTIP;
        }
        else
        {
            Tipcontrol = document.getElementById('divTipFooter');
            if (Tipcontrol != null) {
                Tipcontrol.innerHTML = sTIP;
            }
        }    
     } 
    catch(e) { }
    finally { }
}

function uncheckcontrol(sID)
{ 
    try
    { 	
	    var control = document.getElementById(sID);
	    if( control != null ){control.checked=false;}
    } 
    catch(e) { }  
    finally { } 
}

function showHtmlhelp(context)
{
    //alert('test');
    var hiddenURL =  document.getElementById('hiddenHelpContextURL');
    var url
    if (hiddenURL!=null)
    {
        url = hiddenURL.value
    }
    else
    {
        url = 'HelpGeneral/en-us/index.htm'
    }
    if (context!=null)
    {
        url = url + '?' + context
    }
     
    //alert(hiddenURL.value);
    window.open(url, '', 'top=50, left=100, location=0,status=0,toolbar=0,menubar=0,scrollbars=1,resizable=1,width=750,height=500');
}

/*
 *
 * Javascript implementation of the RSA Data Security, Inc. MD5
 * Message-Digest Algorithm.
 *
 * Some basic logical functions had to be rewritten because of a bug in
 * Javascript.. Just try to compute 0xffffffff >> 4 with it..
 * Of course, these functions are slower than the original would be, but
 * at least, they work!
 */

function integer(n) { return n%(0xffffffff+1); }

function array(n) {
  for(i=0;i<n;i++) this[i]=0;
  this.length=n;
}

function shr(a,b) {
  a=integer(a);
  b=integer(b);
  if (a-0x80000000>=0) {
    a=a%0x80000000;
    a>>=b;
    a+=0x40000000>>(b-1);
  } else
    a>>=b;
  return a;
}

function shl1(a) {
  a=a%0x80000000;
  if (a&0x40000000==0x40000000)
  {
    a-=0x40000000;  
    a*=2;
    a+=0x80000000;
  } else
    a*=2;
  return a;
}

function shl(a,b) {
  a=integer(a);
  b=integer(b);
  for (var i=0;i<b;i++) a=shl1(a);
  return a;
}

function and(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-0x80000000);
  var t2=(b-0x80000000);
  if (t1>=0) 
    if (t2>=0) 
      return ((t1&t2)+0x80000000);
    else
      return (t1&b);
  else
    if (t2>=0)
      return (a&t2);
    else
      return (a&b);  
}

function or(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-0x80000000);
  var t2=(b-0x80000000);
  if (t1>=0) 
    if (t2>=0) 
      return ((t1|t2)+0x80000000);
    else
      return ((t1|b)+0x80000000);
  else
    if (t2>=0)
      return ((a|t2)+0x80000000);
    else
      return (a|b);  
}

function xor(a,b) {
  a=integer(a);
  b=integer(b);
  var t1=(a-0x80000000);
  var t2=(b-0x80000000);
  if (t1>=0) 
    if (t2>=0) 
      return (t1^t2);
    else
      return ((t1^b)+0x80000000);
  else
    if (t2>=0)
      return ((a^t2)+0x80000000);
    else
      return (a^b);  
}

function not(a) {
  a=integer(a);
  return (0xffffffff-a);
}

/* Here begin the real algorithm */

    var state = new array(4); 
    var count = new array(2);
	count[0] = 0;
	count[1] = 0;                     
    var buffer = new array(64); 
    var transformBuffer = new array(16); 
    var digestBits = new array(16);

    var S11 = 7;
    var S12 = 12;
    var S13 = 17;
    var S14 = 22;
    var S21 = 5;
    var S22 = 9;
    var S23 = 14;
    var S24 = 20;
    var S31 = 4;
    var S32 = 11;
    var S33 = 16;
    var S34 = 23;
    var S41 = 6;
    var S42 = 10;
    var S43 = 15;
    var S44 = 21;

    function F(x,y,z) {
	return or(and(x,y),and(not(x),z));
    }

    function G(x,y,z) {
	return or(and(x,z),and(y,not(z)));
    }

    function H(x,y,z) {
	return xor(xor(x,y),z);
    }

    function I(x,y,z) {
	return xor(y ,or(x , not(z)));
    }

    function rotateLeft(a,n) {
	return or(shl(a, n),(shr(a,(32 - n))));
    }

    function FF(a,b,c,d,x,s,ac) {
        a = a+F(b, c, d) + x + ac;
	a = rotateLeft(a, s);
	a = a+b;
	return a;
    }

    function GG(a,b,c,d,x,s,ac) {
	a = a+G(b, c, d) +x + ac;
	a = rotateLeft(a, s);
	a = a+b;
	return a;
    }

    function HH(a,b,c,d,x,s,ac) {
	a = a+H(b, c, d) + x + ac;
	a = rotateLeft(a, s);
	a = a+b;
	return a;
    }

    function II(a,b,c,d,x,s,ac) {
	a = a+I(b, c, d) + x + ac;
	a = rotateLeft(a, s);
	a = a+b;
	return a;
    }

    function transform(buf,offset) { 
	var a=0, b=0, c=0, d=0; 
	var x = transformBuffer;
	
	a = state[0];
	b = state[1];
	c = state[2];
	d = state[3];
	
	for (i = 0; i < 16; i++) {
	    x[i] = and(buf[i*4+offset],0xff);
	    for (j = 1; j < 4; j++) {
		x[i]+=shl(and(buf[i*4+j+offset] ,0xff), j * 8);
	    }
	}

	/* Round 1 */
	a = FF ( a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
	d = FF ( d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
	c = FF ( c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
	b = FF ( b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
	a = FF ( a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
	d = FF ( d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
	c = FF ( c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
	b = FF ( b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
	a = FF ( a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
	d = FF ( d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
	c = FF ( c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
	b = FF ( b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
	a = FF ( a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
	d = FF ( d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
	c = FF ( c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
	b = FF ( b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

	/* Round 2 */
	a = GG ( a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
	d = GG ( d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
	c = GG ( c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
	b = GG ( b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
	a = GG ( a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
	d = GG ( d, a, b, c, x[10], S22,  0x2441453); /* 22 */
	c = GG ( c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
	b = GG ( b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
	a = GG ( a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
	d = GG ( d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
	c = GG ( c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
	b = GG ( b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
	a = GG ( a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
	d = GG ( d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
	c = GG ( c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
	b = GG ( b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

	/* Round 3 */
	a = HH ( a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
	d = HH ( d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
	c = HH ( c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
	b = HH ( b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
	a = HH ( a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
	d = HH ( d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
	c = HH ( c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
	b = HH ( b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
	a = HH ( a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
	d = HH ( d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
	c = HH ( c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
	b = HH ( b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
	a = HH ( a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
	d = HH ( d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
	c = HH ( c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
	b = HH ( b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

	/* Round 4 */
	a = II ( a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
	d = II ( d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
	c = II ( c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
	b = II ( b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
	a = II ( a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
	d = II ( d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
	c = II ( c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
	b = II ( b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
	a = II ( a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
	d = II ( d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
	c = II ( c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
	b = II ( b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
	a = II ( a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
	d = II ( d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
	c = II ( c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
	b = II ( b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

	state[0] +=a;
	state[1] +=b;
	state[2] +=c;
	state[3] +=d;

    }

    function init() {
	count[0]=count[1] = 0;
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;
	for (i = 0; i < digestBits.length; i++)
	    digestBits[i] = 0;
    }

    function update(b) { 
	var index,i;
	
	index = and(shr(count[0],3) , 0x3f);
	if (count[0]<0xffffffff-7) 
	  count[0] += 8;
        else {
	  count[1]++;
	  count[0]-=0xffffffff+1;
          count[0]+=8;
        }
	buffer[index] = and(b,0xff);
	if (index  >= 63) {
	    transform(buffer, 0);
	}
    }

    function finish() {
	var bits = new array(8);
	var	padding; 
	var	i=0, index=0, padLen=0;

	for (i = 0; i < 4; i++) {
	    bits[i] = and(shr(count[0],(i * 8)), 0xff);
	}
        for (i = 0; i < 4; i++) {
	    bits[i+4]=and(shr(count[1],(i * 8)), 0xff);
	}
	index = and(shr(count[0], 3) ,0x3f);
	padLen = (index < 56) ? (56 - index) : (120 - index);
	padding = new array(64); 
	padding[0] = 0x80;
        for (i=0;i<padLen;i++)
	  update(padding[i]);
        for (i=0;i<8;i++) 
	  update(bits[i]);

	for (i = 0; i < 4; i++) {
	    for (j = 0; j < 4; j++) {
		digestBits[i*4+j] = and(shr(state[i], (j * 8)) , 0xff);
	    }
	} 
    }

/* End of the MD5 algorithm */

function hexa(n) {
 var hexa_h = "0123456789abcdef";
 var hexa_c=""; 
 var hexa_m=n;
 for (hexa_i=0;hexa_i<8;hexa_i++) {
   hexa_c=hexa_h.charAt(Math.abs(hexa_m)%16)+hexa_c;
   hexa_m=Math.floor(hexa_m/16);
 }
 return hexa_c;
}


var ascii="01234567890123456789012345678901" +
          " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"+
          "[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";

function MD5(entree) 
{
 var l,s,k,ka,kb,kc,kd;

 init();
 for (k=0;k<entree.length;k++) {
   l=entree.charAt(k);
   update(ascii.lastIndexOf(l));
 }
 finish();
 ka=kb=kc=kd=0;
 for (i=0;i<4;i++) ka+=shl(digestBits[15-i], (i*8));
 for (i=4;i<8;i++) kb+=shl(digestBits[15-i], ((i-4)*8));
 for (i=8;i<12;i++) kc+=shl(digestBits[15-i], ((i-8)*8));
 for (i=12;i<16;i++) kd+=shl(digestBits[15-i], ((i-12)*8));
 s=hexa(kd)+hexa(kc)+hexa(kb)+hexa(ka);
 return s; 
}