with different keys
971632
private org.apache.hadoop.conf.Configuration mirrorCertainHadoopConfig(
		org.apache.hadoop.conf.Configuration hadoopConfig) {
		for (String[] mirrored : mirroredConfigKeys) {
			String value = hadoopConfig.get(mirrored[0], null);
			if (value != null) {
				hadoopConfig.set(mirrored[1], value);
			}
		}
		return hadoopConfig;
	}
98355
function handle2dkeys (keys, value, step, min, max) {
	//up and right - increase by one
	if (keys[38]) {
		value[1] = inc(value[1], plainify(step, 1), 1);
	}
	if (keys[39]) {
		value[0] = inc(value[0], plainify(step, 0), 1);
	}
	if (keys[40]) {
		value[1] = inc(value[1], plainify(step, 1), -1);
	}
	if (keys[37]) {
		value[0] = inc(value[0], plainify(step, 0), -1);
	}

	//meta
	var coordIdx = 1;
	if (keys[18] || keys[91] || keys[17] || keys[16]) coordIdx = 0;

	//home - min
	if (keys[36]) {
		value[coordIdx] = min[coordIdx];
	}

	//end - max
	if (keys[35]) {
		value[coordIdx] = max[coordIdx];
	}

	//pageup
	if (keys[33]) {
		value[coordIdx] = inc(value[coordIdx], plainify(step, coordIdx), PAGE);
	}

	//pagedown
	if (keys[34]) {
		value[coordIdx] = inc(value[coordIdx], plainify(step, coordIdx), -PAGE);
	}


	return value;
}
400779
function(e) {
        if (this.enableKeys) {
            var kc = Event.getCharCode(e);

            switch (kc) {
                case 0x25: // left
                case 0x26: // up
                case 0x27: // right
                case 0x28: // down
                case 0x24: // home
                case 0x23: // end
                    Event.preventDefault(e);
                    break;
                default:
            }
        }
    }
888665
function checkModifierKeys(oEvent, bCtrlKey, bAltKey, bShiftKey) {
		return oEvent.shiftKey == bShiftKey && oEvent.altKey == bAltKey && getCtrlKey(oEvent) == bCtrlKey;
	}
603573
public static void arrangeKeys(ArrayList<String> keys) {
    move(keys, "timestamp", 0);
    move(keys, "hostname", 1);
    move(keys, "type", 2);
  }
463639
def massage_keys(keys):
    """"""
    m_keys = []
    for key in keys:
        if key.startswith('keybase:'):
            m_keys.append(cryptorito.key_from_keybase(key[8:])['fingerprint'])
        else:
            m_keys.append(key)

    return m_keys
251172
def keys(self, pattern, *, encoding=_NOTSET):
        """"""
        return self.execute(b'KEYS', pattern, encoding=encoding)
481199
function keyEventEnum() {
  let modifiers = [
    '', 'CTRL_', 'ALT_', 'SHIFT_', 'CTRL_ALT_', 'CTRL_SHIFT_', 'ALT_SHIFT_',
    'CTRL_ALT_SHIFT_',
  ];
  let charKeys = [
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  ];
  let specialKeys = [
    'SPACE', 'RETURN', 'TAB', 'BACKSPACE', 'ESCAPE',
    'INSERT', 'DELETE', 'HOME', 'END', 'PAGEUP', 'PAGEDOWN',
    'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12',
  ];
  let symbolKeys = [
    'AMPERSAND', 'ASTERISK', 'AT', 'BACKSLASH', 'CARET', 'COLON', 'DOLLAR',
    'EQUALS', 'EXCLAIM', 'GREATER', 'HASH', 'LESS', 'PERCENT', 'PLUS',
    'SEMICOLON', 'SLASH', 'QUESTION', 'QUOTE',
    'QUOTEDBL', 'UNDERSCORE', 'LEFTPAREN', 'RIGHTPAREN',
    'LEFTBRACKET', 'RIGHTBRACKET', 'LEFTBRACE', 'RIGHTBRACE',
  ];
  let arrowKeys = [
    'LEFT', 'RIGHT', 'UP', 'DOWN',
  ];
  let keys = charKeys.concat(specialKeys).concat(symbolKeys).concat(arrowKeys);

  let eventNames = [];
  for (let modifier of modifiers) {
    for (let key of keys) {
      eventNames.push('K_' + modifier + key);
    }
  }
  return eventNames;
}
217052
function(e) {
		gui.Key.ctrlDown = e.ctrlKey;
		gui.Key.shiftDown = e.shiftKey;
		gui.Key.altDown = e.altKey;
		gui.Key.metaDown = e.metaKey;
	}
358707
def difference(self, key, *others):
        """"""
        if not isinstance(key, str):
            raise ValueError("String expected.")
        self.db.sdiffstore(key, [self.key] + [o.key for o in others])
        return Set(key)
860125
def _stringifyKeys(d):
    
    return dict((k.encode('ascii'), v)  for (k, v) in d.iteritems())
812282
public static String makeKey(String... keys) {
        StringBuffer keyBuffer = new StringBuffer();
        for (String s : keys) {
            keyBuffer.append(s);
            keyBuffer.append(":");
        }
        return keyBuffer.toString();
    }
899809
function compareKey(one: string, two: string): number {
  const delta = one.length - two.length;
  if (delta > 0) {
    return 1;
  }
  if (delta < 0) {
    return -1;
  }
  return one > two ? 1 : -1;
}
735110
function newRandomKey(coll, key, currentKey){
      var randKey;
      do {
        randKey = coll[Math.floor(coll.length * Math.random())][key];
      } while (randKey == currentKey);
      return randKey;
    }
989310
def fixed_and_mobile_keys(data)
      if data[Core::FIXED_LINE] == data[Core::MOBILE]
        [Core::FIXED_OR_MOBILE]
      else
        [Core::FIXED_LINE, Core::MOBILE]
      end
    end
302668
function _getKeyInfo(combination, action) {
  var keys,
      key,
      i,
      modifiers = [];

  // take the keys from this pattern and figure out what the actual
  // pattern is all about
  keys = _keysFromString(combination);

  for (i = 0; i < keys.length; ++i) {
    key = keys[i];

    // normalize key names
    if (_SPECIAL_ALIASES[key]) {
      key = _SPECIAL_ALIASES[key];
    }

    // if this is not a keypress event then we should
    // be smart about using shift keys
    // this will only work for US keyboards however
    if (action && action != 'keypress' && _SHIFT_MAP[key]) {
      key = _SHIFT_MAP[key];
      modifiers.push('shift');
    }

    // if this key is a modifier then add it to the list of modifiers
    if (_isModifier(key)) {
      modifiers.push(key);
    }
  }

  // depending on what the key combination is
  // we will try to pick the best event for it
  action = _pickBestAction(key, modifiers, action);

  return {
    key: key,
    modifiers: modifiers,
    action: action
  };
}
867264
def keys_at(self, x):
		
		return [key for key, segs in self.items() if x in segs]