ÿþfunction ntlm(input) {
	
	//hash = input;

	hash = '';
	for (i=0; i<input.length; i++) {
		be = input.charCodeAt(i).toString(16).replace(/^([\da-f])$/,"0$1");
		add = 4-be.length;
		for (a=0; a<add; a++) {
			be = '0' + be;
		}
		
		//posledne 2 znaky
		p1 = be.substr(2, 2);
		p1int = parseInt(p1, 16);
		
		//prva polovica
		p2 = be.substr(0, 2);
		p2int = parseInt(p2, 16);
		
		le = p1+p2;
		leint = parseInt(le, 16);
		//leint = le.toString(10);
		
		//hash = hash + String.fromCharCode(leint);
		hash = hash + String.fromCharCode(p1int) + String.fromCharCode(p2int);
		
		//hash = hash + ' ' + le;
		 
	}
	//alert(hash);
	//alert(bin2hex(hash));
	
	//hash = utf8to16(hash);
	//alert(hash);


	//hash = utf8to16(hash);
	//alert(hash);

	hash = hex_md4(hash);
	//alert(hash);
	//hash = bin2hex(hash);
	//alert(hash);
	hash = strtoupper(hash);

	return hash;
	
}





function bin2hex(s){
    // Converts the binary representation of data to hex  
    // 
    // version: 1009.2513
    // discuss at: http://phpjs.org/functions/bin2hex
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   bugfixed by: Onno Marsman
    // +   bugfixed by: Linuxworld
    // *     example 1: bin2hex('Kev');
    // *     returns 1: '4b6576'
    // *     example 2: bin2hex(String.fromCharCode(0x00));
    // *     returns 2: '00'
    var i, f = 0, a = [];
    
    s += '';
    f = s.length;
    
    for (i = 0; i<f; i++) {
        a[i] = s.charCodeAt(i).toString(16).replace(/^([\da-f])$/,"0$1");
    }
    
    return a.join('');
}

function strtoupper(str) {
    // Makes a string uppercase  
    // 
    // version: 1009.2513
    // discuss at: http://phpjs.org/functions/strtoupper
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: Onno Marsman
    // *     example 1: strtoupper('Kevin van Zonneveld');
    // *     returns 1: 'KEVIN VAN ZONNEVELD'
    return (str+'').toUpperCase();
}



/*
var copyrightConvert = "Copyright © 2000 Mark Davis. All Rights Reserved.";
var globalRadix = 16;
var cuArray = [];
var cpArray = [];
var utf16Array = [];
var parseResult = new ParseResult();
//var outputBytes = 1;
var outputBaseMap = [2,10,16];
var outputLength = 0;

//================

function test() {
  var form = document.mainForm;
  globalRadix = outputBaseMap [form.outputBase.selectedIndex];
  form.mainTextOutput.value = "";
  form.roundtrip.value = "";

  // first box
  form.inputError.value = readInput(form.mainTextInput, form.inputFormat, 16, form.namePrep.checked);
  form.outputError.value = writeOutput(form.mainTextOutput, form.outputFormat, globalRadix);
  form.outputLen.value = outputLength ;
  
  // roundtrip
  form.roundtripLen.value = "";
  form.roundtripError.value = readInput(form.mainTextOutput, form.outputFormat, globalRadix, false);
  if (form.roundtripError.value != "OK") return;
   
  form.roundtripError.value = writeOutput(form.roundtrip, form.inputFormat, 16);
  if (form.roundtripError.value != "OK") return;

  if (form.roundtrip.value != form.mainTextInput.value) {
    form.roundtripError.value = "NO ROUND TRIP";
    return;
  }
  form.roundtripError.value = "OK";
  form.roundtripLen.value = outputLength;
}

//================

function readInput(inputBox, check, radix, namePrep) {
  var textInput = inputBox.value;
  parseResult.set();
  var npParseResult = null;

  if (namePrep) {
    textInput = fold(textInput);
    textInput = NFKC(textInput);
    var badPos = filter(textInput);
    if (badPos >= 0) {
      npParseResult = new ParseResult("Illegal NP character", badPos, textInput.charCodeAt(badPos));
    }
  }

  var which = check.selectedIndex;
  cpArray.length = 0;
  
  switch (which) {
  case 0:
    fromText(textInput, cpArray, parseResult);
    break;
  case 1:
    radixToArray(textInput, cuArray, radix, parseResult);
    if (!parseResult.isError()) fromUTF8(cuArray, cpArray, parseResult);
    break;
  case 2: case 3:
    radixToArray(textInput, cuArray, radix, parseResult);
    if (parseResult.isError()) break;
    if (which == 3) joinFromBytes(cuArray, 2);
    fromUTF16(cuArray, cpArray, parseResult); 
    break;
  case 4: case 5:
    radixToArray(textInput, cuArray, radix, parseResult);
    if (parseResult.isError()) break;
    if (which == 5) joinFromBytes(cuArray, 4);
    checkUTF32(cuArray, parseResult); 
    copyAllTo(cuArray, cpArray);
    break;
  case 6: case 7: case 8: case 9: 
    //debugger;
    if (which <= 7) {
      fromBase32String(textInput, utf16Array, parseResult);
      //alert(arrayToRadix(utf16Array, 16, 0xFF, " ", ""));
    } else {
      radixToArray(textInput, utf16Array, radix, parseResult);
    }
    if (parseResult.isError()) break;
    //alert("utf: " + utf16Array.join(", "));
    var len;
    if ((which % 2) == 0) {
      len = fromRACE(utf16Array, utf16Array.length, cuArray, parseResult);
    } else {
      len = fromLACE(utf16Array, utf16Array.length, cuArray, parseResult);
    }
    //alert("cu: " + cuArray.join(", "));
    if (parseResult.isError()) break;
    cuArray.length = len;
    joinFromBytes(cuArray, 2);
    //alert("bytes: " + cuArray.join(", "));
    fromUTF16(cuArray, cpArray, parseResult);
    break;
  }
  if (npParseResult != null) return npParseResult.toString();
  return parseResult.toString();
}

//================

function writeOutput(output, check, radix) {
  output.value = "";
  var which = check.selectedIndex;
  var pattern = document.mainForm.pattern.value;
  if (pattern.indexOf('@') < 0) {
    document.mainForm.pattern.value = pattern += '@';
  }
  var str = "";
  var max = 0;

  switch (which) {
  case 0:
    str = toText(cpArray, parseResult);
    outputLength =str.length;
    break;
  case 1:
    toUTF8(cpArray, cuArray, parseResult); 
    str = arrayToRadix(cuArray, radix, 0xFF, pattern); 
    outputLength =cuArray.length;
    break;
  case 2: case 3:
    toUTF16(cpArray, cuArray, parseResult);
    max = 0xFFFF;
    if (which==3) {
      breakIntoBytes(cuArray,2);
      max = 0xFF;
    }
    str = arrayToRadix(cuArray, radix, max, pattern);
    outputLength =cuArray.length;
    break;
  case 4: case 5:
    checkUTF32(cpArray, parseResult);
    copyAllTo(cpArray, cuArray); 
    max = 0xFFFFFFFF;
    if (which == 5) {
      breakIntoBytes(cuArray,4);
      max = 0xFF;
    }
    str =arrayToRadix(cuArray, radix, max, pattern);
    outputLength =cuArray.length;
    break;
  case 6: case 7: case 8: case 9: 
    toUTF16(cpArray, utf16Array, parseResult);
    //alert(utf16Array.join(", "));
    if (parseResult.isError()) break;
    breakIntoBytes(utf16Array,2);
    //alert(utf16Array.join(", "));
    var len;
    if ((which % 2) == 0) {
      len = toRACE(utf16Array, utf16Array.length, cuArray, parseResult);    
    } else {
      len = toLACE(utf16Array, utf16Array.length, cuArray, parseResult);
    }
    if (parseResult.isError()) break;
    cuArray.length = len;
    if (which > 7) {
      str = arrayToRadix(cuArray, radix, 0xFF, pattern);
      outputLength =cuArray.length;
    } else {
      str = toBase32String(cuArray, parseResult);
      //alert(arrayToRadix(cuArray, 16, 0xFF, " ", ""));
      outputLength =str.length;
    }
    break;
  }    
  output.value = str;
  return parseResult.toString();
}

//================

function show(obj) {
  var result = "";
  for (var key in obj) {
    if (obj[key] != null) result +=  key  + "=" + obj[key] + "; ";
  }
  return result;
}

function insertChoice() {
  document.mainForm.inputFormat.selectedIndex = 0;
  var index = document.mainForm.insertText.selectedIndex;
  if (index != 0) document.mainForm.mainTextInput.value += document.mainForm.insertText[index].text;
  document.mainForm.insertText.selectedIndex = 0;
  test();
}

*/