Combine arguments into cbo
@function combine

@param {cbo} cbo - A cbo object
@param {Array} [argArrayExtra] - Extra arguments array
@param {bool} [insertBefore] - Flag to insert `argArrayExtra` before original `argArray` of `cbo`

@returns A new cbo
162840
function combine(cbo, argArrayExtra, insertBefore) {
	return [cbo[0], cbo[1], cbo[2] ? (insertBefore ? argArrayExtra.concat(cbo[2]) : cbo[2].concat(argArrayExtra)) : argArrayExtra];
}
74907
def insert_before(self, value: Union[RawValue, Value],
                      raw: bool = False) -> "ArrayEntry":
        
        return ArrayEntry(self.index, self.before, self.after.cons(self.value),
                          self._cook_value(value, raw), self.parinst,
                          self.schema_node, datetime.now())
299418
function mixAppend(to)
{
  var args = Array.prototype.slice.call(arguments)
    , i    = 0
    ;

  // it will start with `1` – second argument
  // leaving `to` out of the loop
  while (++i < args.length)
  {
    copy(to, args[i]);
  }

  return to;
}
42994
public void combine(Vector new_filters, int op) throws DBException
    {
        for (Enumeration elems = new_filters.elements(); elems.hasMoreElements();)
        {
            SearchFilter filter = (SearchFilter) elems.nextElement();

            combine(filter, op);
        }
    }
889107
function _combineObject(params, arr) {
  var ret = {};
  _lodash2.default.each(arr, function (arg, i) {
    ret[params[i]] = arg;
  });
  return ret;
}
181694
function mergeInto(one, two) {
  checkMergeObjectArg(one);
  if (two != null) {
    checkMergeObjectArg(two);
    for (var key in two) {
      if (!two.hasOwnProperty(key)) {
        continue;
      }
      one[key] = two[key];
    }
  }
}
529662
function mergeArrays (a, b) {
    // if target is array then add b to array otherwise return undefined
    // so normal _.merge will be performed
    return Array.isArray(a) ? a.concat(b) : undefined
}
50797
function arrayUniq (array) {
  var result = []
  baseExports.each(array, function (value) {
    if (!result.includes(value)) {
      result.push(value)
    }
  })
  return result
}
723197
function mergeArrays(objValue, srcValue) {
  if (isArray(objValue) && isArray(srcValue)) {
    return objValue.concat(srcValue)
  }
}
720693
function ( prev, curr ) {
  var c,
      cmax = curr.length;
  var p,
      pmax = prev.length;
  var result = [];

  for ( p = 0; p < pmax; p += 1 ) {
    for ( c = 0; c < cmax; c += 1 ) {
      result.push( prev[ p ].concat( curr[ c ] ) );
    }
  }
  return ( result );
}
984798
function concat (target, data) {
    target = target || []
    if(Object.prototype.toString.call(data)!=='[object Array]') {
        data = [data]
    }
    Array.prototype.push.apply(target, data)
    return target
  }
576964
function createSerialCombinations(arr, fn) {
  var combinations = [''];
  var newCombinations;
  arr.forEach(function (elements) {
    newCombinations = [];
    elements.forEach(function (element) {
      combinations.forEach(function (combination) {
        newCombinations.push(fn(combination, element));
      });
    });
    combinations = newCombinations;
  });
  return combinations;
}
41046
function mergeParams (params, addition) {
	var ret;

	if (!params){
		// if it's uncontested, then just return the addition.
		ret = addition;
	} else if (braintree_util.isArray(params)) {
		// if the existing value is an array, then concat it.
		ret = params.concat(addition);
	} else if (!braintree_util.isObject(params) || !braintree_util.isObject(addition)) {
		// if the existing value is not an array, and either are not objects, arrayify it.
		ret = [params].concat(addition);
	} else {
		// else merge them as objects, which is a little more complex
		ret = mergeObjects(params, addition);
	}
	return ret;
}
721144
function condMerge(arg) {
    var args = arg.filter(function (v) {
        return !!v;
    });
    if (args[0] && args[0].empty && args.length > 1) {
        delete args[0].empty;
    }
    return _mergeOptions2.default.apply(undefined, _toConsumableArray(args));
}
258024
function mergeOne(dst, src) {
  if (src === undefined) return dst;

  // According to specification arrays must be concatenated.
  // Also, the '.concat' creates a new array instance. Overrides the 'dst'.
  if (isArray(src)) return (isArray(dst) ? dst : []).concat(src);

  // Now deal with non plain 'src' object. 'src' overrides 'dst'
  // Note that functions are also assigned! We do not deep merge functions.
  if (!isPlainObject(src)) return src;

  // See if 'dst' is allowed to be mutated.
  // If not - it's overridden with a new plain object.
  var returnValue = isObject(dst) ? dst : {};

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

    var srcValue = src[key];
    // Do not merge properties with the 'undefined' value.
    if (srcValue !== undefined) {
      var dstValue = returnValue[key];
      // Recursive calls to mergeOne() must allow only plain objects or arrays in dst
      var newDst = isPlainObject(dstValue) || isArray(srcValue) ? dstValue : {};

      // deep merge each property. Recursion!
      returnValue[key] = mergeOne(newDst, srcValue);
    }
  }

  return returnValue;
}
495465
function addBinaries(binaries) {
	var SLICE = Array.prototype.slice;
	//iterate backwards to mimic normal resolution order
	for (var i = binaries.length-1; i >= 0; i--) {
		var parts = binaries[i].split('/');
		(function() {var name = parts[parts.length-1];
		exports[name] = function() {

			//grab the last argument, which might be a callback

			var cbs = SLICE.call(arguments, 3);
			//assume none of the args we got were handlers
			var args = SLICE.call(arguments);
			var argLength = args.length;
		
			var cb, stdoutHandler, stderrHandler, options;
			if (args[argLength-3] instanceof Function) {
				//we have all 3
				stderrHandler = args.pop();
				stdoutHandler = args.pop();
				cb = args.pop();
			} else if (arguments[argLength-2] instanceof Function) {
				//we have cb and stdout 
				stdoutHandler = args.pop();
				cb = args.pop();
			} else if (arguments[argLength-1] instanceof Function) {
				//we have cb only
				cb = args.pop();
			}

			//if the last arg is an object, it's the options object
			var lastArg = args[args.length-1];
			if (typeof lastArg == 'object' && !lastArg.length) {
				options = args.pop();
			}
			//if the first argument was an array, the args were passed as
			//an array
			if (args[0] instanceof Array) {
				args = args[0];
			}
			
			return runCommand(name, args, options, cb, stdoutHandler, stderrHandler);

		};})();
	}
}
985174
function arrayMergeUnique(a, b) {
  return a.concat(b).filter(function(v,i,c) {
    if(i === c.indexOf(v)) return true
    return false
  })
}