Takes each argument and outputs the obfuscated version of it.
965292
public static void main(String[] args) {
    for (int i = 0; i < args.length; i++)
      System.out.println("'" + args[i] + "' becomes '" + obfuscate(args[i]) + "'");
  }

  /**
   * Takes a string and returns an obfuscated string with no more than 2x a many characters as the
   * original. Only works in the DEV environment.
   */
  public static String obfuscate(String plaintext) {
    String blargtext = StringMan.encodeBytesToString(mangleArray(plaintext.getBytes()));
    blargtext = StringMan.compressHexString(blargtext);
    return blargtext;
  }

  /** Opposite of {@link #obfuscate(String)} */
  public static String clarify(String blargtext) {
    if (blargtext == null)
      return null;
    byte blargBytes[] = decodeStringToBytes(blargtext);
    String plaintext = new String(mangleArray(blargBytes));
    return plaintext;
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static byte[] decodeStringToBytes(String hex) {
    hex = decompressHexString(hex);
    int stringLength = hex.length();
    byte[] b = new byte[stringLength / 2];
    for (int i = 0, j = 0; i < stringLength; i += 2, j++) {
      int high = charToNibble(hex.charAt(i));
      int low = charToNibble(hex.charAt(i + 1));
      b[j] = (byte) ((high << 4) | low);
    }
    return b;
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static int charToNibble(char c) {
    if ('0' <= c && c <= '9')
      return c - '0';
    else if ('a' <= c && c <= 'f')
      return c - 'a' + 0xa;
    else if ('A' <= c && c <= 'F')
      return c - 'A' + 0xa;
    else
      throw new IllegalArgumentException("Invalid hex character: " + c);
  }

  /** Inlined from StringManipulator due to static init circular references, called by clarify */
  private static String decompressHexString(String in) {
    StringBuffer out = new StringBuffer();
    for (int i = 0; i < in.length(); i++) {
      char thisChar = in.charAt(i);
      if (thisChar != '^') {
        out.append(thisChar);
      } else {
        thisChar = in.charAt(i + 1);
        int count = "abcdefghijklmnopqrstuvwxyz01234567890".indexOf(in.charAt(i + 2));
        for (int j = 0; j < count; j++)
          out.append(thisChar);
        i += 2;
      }
    }
    return out.toString();
  }

  /**
   * Takes a given byte array and mangles it by XOR'ing it with a secret garbage hash. It is
   * reversible, so calling mangleArray(mangleArray(blah)) will return the original array.
   * 
   * @return the mangled array (Same size as the input array)
   */
  private static byte[] mangleArray(byte plainBytes[]) {
    if (plainBytes == null)
      return null;
    byte mangled[] = new byte[plainBytes.length];
    byte hash[] = SUPER_SECRET_MANGLE_STRING.getBytes();
    for (int i = 0; i < plainBytes.length; i++) {
      byte current = (byte) (plainBytes[i] ^ hash[i % hash.length]);
      mangled[i] = current;
    }
    return mangled;
  }

}
73112
function sanitizeFalsies(obj) {
	var key;
	if (!obj._) {
		delete obj._;
		for (key in obj) {
			if (obj[key] === false) delete obj[key];
		}
	}
	return obj;
}
601723
def map_arg(**maps):
    
    def deco(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if six.PY2:
                argmap = inspect.getcallargs(func, *args, **kwargs)
            else:
                # getcallargs was deprecated since 3.5
                sig = inspect.signature(func)
                argmap = sig.bind_partial(*args, **kwargs).arguments
            for k, map_func in six.iteritems(maps):
                if k in argmap:
                    argmap[k] = map_func(argmap[k])
            return func(**argmap)
        return wrapper
    return deco
362390
def verifyArguments(self, arg):
        
        for l in arg:
            if not type(l) == list and \
               not type(l) == type(Numeric.array([0.0])) and \
               not type(l) == tuple and \
               not type(l) == dict:
                return 0
            if type(l) == dict:
                for i in l:
                    if not type(i) == str and i not in list(self.layers.keys()):
                        return 0
            else:
                for i in l:
                    if not type(i) == float and not type(i) == int:
                        return 0
        return 1
638985
def encode_args(args, extra=False):
    
    if not args:
        return ''

    methodargs = ', '.join([encode(a) for a in args])
    if extra:
        methodargs += ', '

    return methodargs
928958
public static String obfuscate(String s)
    {
        StringBuffer buf = new StringBuffer();
        byte[] b = s.getBytes();
        
        synchronized(buf)
        {
            buf.append("OBF:");
            for (int i=0;i<b.length;i++)
            {
                byte b1 = b[i];
                byte b2 = b[s.length()-(i+1)];
                int i1= (int)b1+(int)b2+127;
                int i2= (int)b1-(int)b2+127;
                int i0=i1*256+i2;
                String x=Integer.toString(i0,36);

                switch(x.length())
                {
                  case 1:buf.append('0');
                  case 2:buf.append('0');
                  case 3:buf.append('0');
                  default:buf.append(x);
                }
            }
            return buf.toString();
        }
    }
719750
def normalize_args(f, *args, **kwargs):
    
    callargs = inspect.getcallargs(f, *args, **kwargs)
    original_callargs = callargs.copy()
    try:
        argspec = inspect.getargspec(f)
    except ValueError:
        argspec = inspect.getfullargspec(f)
    else:
        argspec = fullargspec_from_argspec(argspec)

    if hasattr(argspec, 'varkw'):
        if argspec.varkw:
            kwargs = callargs.pop(argspec.varkw, {})
            callargs.update(kwargs)

    if argspec.varargs:
        varargs = callargs.pop(argspec.varargs, ())
    else:
        varargs = ()

    # now callargs is all keywords

    return NormalizedArgs(varargs=varargs,
                          normargs=callargs,
                          callargs=original_callargs)
1236698
def deco_args
      return "" if args.empty?

      my_args = args.map do |arg|
        prefix, default = prefix_and_default(arg[0])

        kls = use_short_style?(arg) ? "" : "##{locals[arg[1]].class}"

        "#{prefix}#{arg[1] || default}#{kls}"
      end

      "(#{my_args.join(', ')})"
    end
1332181
def parse_args(self, flags, namespace):
    """"""
    flag_value_map = self._create_flag_value_map(flags)

    mutex_map = defaultdict(list)
    for args, kwargs in self._unnormalized_option_registrations_iter():
      self._validate(args, kwargs)
      dest = self.parse_dest(*args, **kwargs)

      # Compute the values provided on the command line for this option.  Note that there may be
      # multiple values, for any combination of the following reasons:
      #   - The user used the same flag multiple times.
      #   - The user specified a boolean flag (--foo) and its inverse (--no-foo).
      #   - The option has multiple names, and the user used more than one of them.
      #
      # We also check if the option is deprecated, but we only do so if the option is explicitly
      # specified as a command-line flag, so we don't spam users with deprecated option values
      # specified in config, which isn't something they control.
      implicit_value = kwargs.get('implicit_value')
      if implicit_value is None and kwargs.get('type') == bool:
        implicit_value = True  # Allows --foo to mean --foo=true.

      flag_vals = []

      def add_flag_val(v):
        if v is None:
          if implicit_value is None:
            raise ParseError('Missing value for command line flag {} in {}'.format(
              arg, self._scope_str()))
          else:
            flag_vals.append(implicit_value)
        else:
          flag_vals.append(v)

      for arg in args:
        # If the user specified --no-foo on the cmd line, treat it as if the user specified
        # --foo, but with the inverse value.
        if kwargs.get('type') == bool:
          inverse_arg = self._inverse_arg(arg)
          if inverse_arg in flag_value_map:
            flag_value_map[arg] = [self._invert(v) for v in flag_value_map[inverse_arg]]
            implicit_value = self._invert(implicit_value)
            del flag_value_map[inverse_arg]

        if arg in flag_value_map:
          for v in flag_value_map[arg]:
            add_flag_val(v)
          del flag_value_map[arg]

      # Get the value for this option, falling back to defaults as needed.
      try:
        val = self._compute_value(dest, kwargs, flag_vals)
      except ParseError as e:
        # Reraise a new exception with context on the option being processed at the time of error.
        # Note that other exception types can be raised here that are caught by ParseError (e.g.
        # BooleanConversionError), hence we reference the original exception type as type(e).
        raise type(e)(
          'Error computing value for {} in {} (may also be from PANTS_* environment variables).'
          '\nCaused by:\n{}'.format(', '.join(args), self._scope_str(), traceback.format_exc())
        )

      # If the option is explicitly given, check deprecation and mutual exclusion.
      if val.rank > RankedValue.HARDCODED:
        self._check_deprecated(dest, kwargs)

        mutex_dest = kwargs.get('mutually_exclusive_group')
        if mutex_dest:
          mutex_map[mutex_dest].append(dest)
          dest = mutex_dest
        else:
          mutex_map[dest].append(dest)

        if len(mutex_map[dest]) > 1:
          raise self.MutuallyExclusiveOptionError(
            "Can only provide one of the mutually exclusive options {}".format(mutex_map[dest]))

      setattr(namespace, dest, val)

    # See if there are any unconsumed flags remaining.
    if flag_value_map:
      raise ParseError('Unrecognized command line flags on {}: {}'.format(
        self._scope_str(), ', '.join(flag_value_map.keys())))

    return namespace
737752
def stripArgs(args, blacklist):
		
		blacklist = [b.lower() for b in blacklist]
		return list([arg for arg in args if arg.lower() not in blacklist])
766304
def is_ascii_obfuscation(vm):
    
    for classe in vm.get_classes():
        if is_ascii_problem(classe.get_name()):
            return True
        for method in classe.get_methods():
            if is_ascii_problem(method.get_name()):
                return True
    return False
935725
function _gpfFuncUnsafe (params, source) {
    var args;
    if (!params.length) {
        return _GpfFunc(source);
    }
    args = [].concat(params);
    args.push(source);
    return _GpfFunc.apply(null, args);
}
1059112
function obfusicate(str) {
        if (!angular.isString(str)) {
            // return null so we don't show any old random non-string thing
            return null;
        }
        return str.split('').map(function (c) { return '*'; }).join('');
    }
293495
def verify_arguments(self, args=None, kwargs=None):
        

        args = self.args if args is None else args
        kwargs = self.kwargs if kwargs is None else kwargs

        try:
            verify_arguments(self._target, self._method_name, args, kwargs)
        except VerifyingBuiltinDoubleArgumentError:
            if doubles.lifecycle.ignore_builtin_verification():
                raise
866152
private static byte[] deobfuscateBytes(byte[] source) {

        byte[] result = new byte[source.length - 1];
        System.arraycopy(source, 1, result, 0, source.length - 1);
        for (int i = 0; i < result.length; i++) {
            result[i] = (byte)(0xFF & (result[i] ^ source[0]));
        }
        return result;
    }
1334324
function cleanHorribleOutput(x) {
  if (x && x.$) {
    _.extend(x, x.$);
    delete(x.$);
  }

  _.each(x, function(value, prop) {
    if (_.isArray(value) || _.isObject(value)) {
      cleanHorribleOutput(value);
    }
  });

  return x;
}
1254685
static String[] removeArgsNotAffectingState(String[] args) {
        String[] out = new String[args.length];
        int j = 0;
        for (int i = 0; i<args.length; ++i) {
            if (args[i].equals("-j")) {
                // Just skip it and skip following value
                i++;
            } else if (args[i].startsWith("--server:")) {
                // Just skip it.
            } else if (args[i].startsWith("--log=")) {
                // Just skip it.
            } else if (args[i].equals("--compare-found-sources")) {
                // Just skip it and skip verify file name
                i++;
            } else {
                // Copy argument.
                out[j] = args[i];
                j++;
            }
        }
        String[] ret = new String[j];
        System.arraycopy(out, 0, ret, 0, j);
        return ret;
    }