Visit OP_CONCAT_DELETE
169633
private void visit_OP_CONCAT_DELETE() throws IOException {
    visitTxId();
    int sourceCount = 0;
    if (!LayoutVersion.supports(Feature.EDITLOG_OP_OPTIMIZATION, editsVersion)) {
      IntToken lengthToken = v.visitInt(EditsElement.LENGTH);
      sourceCount = lengthToken.value - 2;
      Log.info("------------------------- does not support");
    }
    v.visitStringUTF8(EditsElement.CONCAT_TARGET);
    // all except of CONCAT_TARGET and TIMESTAMP
    if (LayoutVersion.supports(Feature.EDITLOG_OP_OPTIMIZATION, editsVersion)) {
      IntToken lengthToken = v.visitInt(EditsElement.LENGTH);
      sourceCount = lengthToken.value;
      Log.info("------------------------- does support");
    }
    for(int i = 0; i < sourceCount; i++) {
      v.visitStringUTF8(EditsElement.CONCAT_SOURCE);
    }
    if (LayoutVersion.supports(Feature.EDITLOG_OP_OPTIMIZATION, editsVersion)) {
      v.visitLong(EditsElement.TIMESTAMP);
    } else {
      v.visitStringUTF8(EditsElement.TIMESTAMP);
    }
  }
1209016
function _delete(name) {
    observers[name].unobserve();
    delete observers[name];
    delete u        [name];
    delete shadow   [name];
  }
469619
function _concat(buffOne, buffTwo) {
  if (!buffOne) return buffTwo;
  if (!buffTwo) return buffOne;

  let newLength = buffOne.length + buffTwo.length;
  return Buffer.concat([buffOne, buffTwo], newLength);
}
208078
def apply_operation(op_stack, out_stack):
    
    out_stack.append(calc(out_stack.pop(), out_stack.pop(), op_stack.pop()))
1250028
function concat(a,o,dest,p,replacement){

	if(a.length > 0) {

		var content = '';
		// console.log(a);
		// var a = a.reverse();
		var rel = path.dirname(path.relative(dest,p));
		fs.writeFileSync(o,'',{
			encoding:'utf8'
		});
		a.forEach(function(v){
			// var ap = path.resolve(pwd,dest,v);
			var ap = path.resolve(pwd,dest,rel,v);
			if(replacement){
				ap = ap.replace(replacement.from,replacement.to);
			}
			if(!fs.existsSync(ap)){
				return;
			}
			var str = read(ap).toString('utf8');
			str += '\n';
			fs.appendFileSync(o,str);
		});
		return read(o).toString('utf8');

	} else {
		return null;
	}

}
175670
def list_concat(input, **params):
    
    PARAM_SOURCE_FIELDS = 'src.fields'
    PARAM_DEST_FIELD = 'dest.field'

    field_list = params.get(PARAM_SOURCE_FIELDS)
    for row in input:
        res = []
        for field in field_list:
            res += row[field]
        row[params.get(PARAM_DEST_FIELD)] = res
    return input
639521
function execute( op ) {
		writeToA = 0;
		address = 0xf0000;

		debugPC = PC;

		switch( op ) {
		case 0x3e:
			absoluteIndexedX();
			ROL();
			burn(7);
			break;
		case 0x3d:
			absoluteIndexedX();
			AND();
			burn(4);
			break;
		case 0x85:
			zeroPage();
			STA();
			burn(3);
			break;
		case 0x84:
			zeroPage();
			STY();
			burn(3);
			break;
		case 0x28:
			implied();
			PLP();
			burn(4);
			break;
		case 0x29:
			immediate();
			AND();
			burn(2);
			break;
		case 0xf8:
			implied();
			SED();
			burn(2);
			break;
		case 0xf9:
			absoluteIndexedY();
			SBC();
			burn(4);
			break;
		case 0xf6:
			zeroPageIndexedX();
			INC();
			burn(6);
			break;
		case 0x20:
			absolute();
			JSR();
			burn(6);
			break;
		case 0x21:
			indexedIndirectX();
			AND();
			burn(6);
			break;
		case 0x26:
			zeroPage();
			ROL();
			burn(5);
			break;
		case 0x86:
			zeroPage();
			STX();
			burn(3);
			break;
		case 0x24:
			zeroPage();
			BIT();
			burn(3);
			break;
		case 0x25:
			zeroPage();
			AND();
			burn(2);
			break;
		case 0x35:
			zeroPageIndexedX();
			AND();
			burn(3);
			break;
		case 0x36:
			zeroPageIndexedX();
			ROL();
			burn(6);
			break;
		case 0x31:
			indirectIndexedY();
			AND();
			burn(5);
			break;
		case 0x30:
			relative();
			BMI();
			burn(2);
			break;
		case 0x39:
			absoluteIndexedY();
			AND();
			burn(4);
			break;
		case 0x38:
			implied();
			SEC();
			burn(2);
			break;
		case 0x8c:
			absolute();
			STY();
			burn(4);
			break;
		case 0x2c:
			absolute();
			BIT();
			burn(4);
			break;
		case 0xfd:
			absoluteIndexedX();
			SBC();
			burn(4);
			break;
		case 0xfe:
			absoluteIndexedX();
			INC();
			burn(7);
			break;
		case 0x2d:
			absolute();
			AND();
			burn(4);
			break;
		case 0x2e:
			absolute();
			ROL();
			burn(6);
			break;
		case 0xba:
			implied();
			TSX();
			burn(2);
			break;
		case 0x5e:
			absoluteIndexedX();
			LSR();
			burn(7);
			break;
		case 0x5d:
			absoluteIndexedX();
			EOR();
			burn(4);
			break;
		case 0x40:
			implied();
			RTI();
			burn(6);
			break;
		case 0x41:
			indexedIndirectX();
			EOR();
			burn(6);
			break;
		case 0x45:
			zeroPage();
			EOR();
			burn(3);
			break;
		case 0x46:
			zeroPage();
			LSR();
			burn(5);
			break;
		case 0x48:
			implied();
			PHA();
			burn(3);
			break;
		case 0x49:
			immediate();
			EOR();
			burn(2);
			break;
		case 0xae:
			absolute();
			LDX();
			burn(4);
			break;
		case 0xad:
			absolute();
			LDA();
			burn(4);
			break;
		case 0xac:
			absolute();
			LDY();
			burn(4);
			break;
		case 0xaa:
			implied();
			TAX();
			burn(2);
			break;
		case 0x4a:
			accumulator();
			LSR();
			burn(2);
			break;
		case 0x4c:
			absolute();
			JMP();
			burn(3);
			break;
		case 0x4d:
			absolute();
			EOR();
			burn(4);
			break;
		case 0x4e:
			absolute();
			LSR();
			burn(6);
			break;
		case 0x51:
			indirectIndexedY();
			EOR();
			burn(5);
			break;
		case 0x50:
			relative();
			BVC();
			burn(2);
			break;
		case 0x56:
			zeroPageIndexedX();
			LSR();
			burn(6);
			break;
		case 0x55:
			zeroPageIndexedX();
			EOR();
			burn(4);
			break;
		case 0x9a:
			implied();
			TXS();
			burn(2);
			break;
		case 0xe5:
			zeroPage();
			SBC();
			burn(3);
			break;
		case 0x59:
			absoluteIndexedY();
			EOR();
			burn(4);
			break;
		case 0x58:
			implied();
			CLI();
			burn(2);
			break;
		case 0x2a:
			accumulator();
			ROL();
			burn(2);
			break;
		case 0xa9:
			immediate();
			LDA();
			burn(2);
			break;
		case 0xa8:
			implied();
			TAY();
			burn(2);
			break;
		case 0xa6:
			zeroPage();
			LDX();
			burn(3);
			break;
		case 0xa5:
			zeroPage();
			LDA();
			burn(3);
			break;
		case 0xa2:
			immediate();
			LDX();
			burn(2);
			break;
		case 0xa1:
			indexedIndirectX();
			LDA();
			burn(6);
			break;
		case 0xa0:
			immediate();
			LDY();
			burn(2);
			break;
		case 0xa4:
			zeroPage(0);
			LDY();
			burn(3);
			break;
		case 0xf5:
			zeroPageIndexedX();
			SBC();
			burn(4);
			break;
		case 0x7e:
			absoluteIndexedX();
			ROR();
			burn(7);
			break;
		case 0x7d:
			absoluteIndexedX();
			ADC();
			burn(4);
			break;
		case 0xf0:
			relative();
			BEQ();
			burn(2);
			break;
		case 0x68:
			implied();
			PLA();
			burn(4);
			break;
		case 0x69:
			immediate();
			ADC();
			burn(2);
			break;
		case 0x66:
			zeroPage();
			ROR();
			burn(5);
			break;
		case 0x65:
			zeroPage();
			ADC();
			burn(3);
			break;
		case 0x60:
			implied();
			RTS();
			burn(6);
			break;
		case 0x61:
			indexedIndirectX();
			ADC();
			burn(6);
			break;
		case 0xce:
			absolute();
			DEC();
			burn(6);
			break;
		case 0xcd:
			absolute();
			CMP();
			burn(4);
			break;
		case 0xb8:
			implied();
			CLV();
			burn(2);
			break;
		case 0xb9:
			absoluteIndexedY();
			LDA();
			burn(4);
			break;
		case 0xca:
			implied();
			DEX();
			burn(2);
			break;
		case 0xcc:
			absolute();
			CPY();
			burn(4);
			break;
		case 0xb0:
			relative();
			BCS();
			burn(2);
			break;
		case 0xb1:
			indirectIndexedY();
			LDA();
			burn(5);
			break;
		case 0xb6:
			zeroPageIndexedY();
			LDX();
			burn(4);
			break;
		case 0xb4:
			zeroPageIndexedX();
			LDY();
			burn(4);
			break;
		case 0xb5:
			zeroPageIndexedX();
			LDA();
			burn(4);
			break;
		case 0x8a:
			implied();
			TXA();
			burn(2);
			break;
		case 0x6d:
			absolute();
			ADC();
			burn(4);
			break;
		case 0x6e:
			absolute();
			ROR();
			burn(6);
			break;
		case 0x6c:
			indirect();
			JMP();
			burn(5);
			break;
		case 0x6a:
			accumulator();
			ROR();
			burn(2);
			break;
		case 0x79:
			absoluteIndexedY();
			ADC();
			burn(4);
			break;
		case 0x78:
			implied();
			SEI();
			burn(2);
			break;
		case 0x71:
			indirectIndexedY();
			ADC();
			burn(5);
			break;
		case 0x70:
			relative();
			BVS();
			burn(2);
			break;
		case 0x75:
			zeroPageIndexedX();
			ADC();
			burn(4);
			break;
		case 0x76:
			zeroPageIndexedX();
			ROR();
			burn(6);
			break;
		case 0xc5:
			zeroPage();
			CMP();
			burn(3);
			break;
		case 0xc4:
			zeroPage();
			CPY();
			burn(3);
			break;
		case 0xc6:
			zeroPage();
			DEC();
			burn(5);
			break;
		case 0xc1:
			indexedIndirectX();
			CMP();
			burn(6);
			break;
		case 0xc0:
			immediate();
			CPY();
			burn(2);
			break;
		case 0xbc:
			absoluteIndexedX();
			LDY();
			burn(4);
			break;
		case 0xe4:
			zeroPage();
			CPX();
			burn(3);
			break;
		case 0xc9:
			immediate();
			CMP();
			burn(2);
			break;
		case 0xc8:
			implied();
			INY();
			burn(2);
			break;
		case 0xbd:
			absoluteIndexedX();
			LDA();
			burn(4);
			break;
		case 0xbe:
			absoluteIndexedY();
			LDX();
			burn(4);
			break;
		case 0xf1:
			indirectIndexedY();
			SBC();
			burn(5);
			break;
		case 0xe9:
			immediate();
			SBC();
			burn(2);
			break;
		case 0xd0:
			relative();
			BNE();
			burn(2);
			break;
		case 0xd1:
			indirectIndexedY();
			CMP();
			burn(5);
			break;
		case 0x9d:
			absoluteIndexedX();
			STA();
			burn(5);
			break;
		case 0x08:
			implied();
			PHP();
			burn(3);
			break;
		case 0xd5:
			zeroPageIndexedX();
			CMP();
			burn(4);
			break;
		case 0xd6:
			zeroPageIndexedX();
			DEC();
			burn(6);
			break;
		case 0xd8:
			implied();
			CLD();
			burn(2);
			break;
		case 0xd9:
			absoluteIndexedY();
			CMP();
			burn(4);
			break;
		case 0x06:
			zeroPage();
			ASL();
			burn(5);
			break;
		case 0x00:
			implied();
			BRK();
			burn(7);
			break;
		case 0x01:
			indexedIndirectX();
			ORA();
			burn(6);
			break;
		case 0xec:
			absolute();
			CPX();
			burn(4);
			break;
		case 0x05:
			zeroPage();
			ORA();
			burn(2);
			break;
		case 0xea:
			implied();
			NOP();
			burn(2);
			break;
		case 0x81:
			indexedIndirectX();
			STA();
			burn(6);
			break;
		case 0xee:
			absolute();
			INC();
			burn(6);
			break;
		case 0xed:
			absolute();
			SBC();
			burn(4);
			break;
		case 0x1e:
			absoluteIndexedX();
			ASL();
			burn(7);
			break;
		case 0x1d:
			absoluteIndexedX();
			ORA();
			burn(4);
			break;
		case 0x88:
			implied();
			DEY();
			burn(2);
			break;
		case 0x09:
			immediate();
			ORA();
			burn(2);
			break;
		case 0x8d:
			absolute();
			STA();
			burn(4);
			break;
		case 0x8e:
			absolute();
			STX();
			burn(4);
			break;
		case 0xe1:
			indexedIndirectX();
			SBC();
			burn(6);
			break;
		case 0xe0:
			immediate();
			CPX();
			burn(2);
			break;
		case 0xe6:
			zeroPage();
			INC();
			burn(5);
			break;
		case 0x19:
			absoluteIndexedY();
			ORA();
			burn(4);
			break;
		case 0x18:
			implied();
			CLC();
			burn(2);
			break;
		case 0x16:
			zeroPageIndexedX();
			ASL();
			burn(6);
			break;
		case 0x15:
			zeroPageIndexedX();
			ORA();
			burn(3);
			break;
		case 0xe8:
			implied();
			INX();
			burn(2);
			break;
		case 0x11:
			indirectIndexedY();
			ORA();
			burn(5);
			break;
		case 0x10:
			relative();
			BPL();
			burn(2);
			break;
		case 0x96:
			zeroPageIndexedY();
			STX();
			burn(4);
			break;
		case 0x95:
			zeroPageIndexedX();
			STA();
			burn(4);
			break;
		case 0x94:
			zeroPageIndexedX();
			STY();
			burn(4);
			break;
		case 0xdd:
			absoluteIndexedX();
			CMP();
			burn(4);
			break;
		case 0xde:
			absoluteIndexedX();
			DEC();
			burn(7);
			break;
		case 0x91:
			indirectIndexedY();
			STA();
			burn(6);
			break;
		case 0x90:
			relative();
			BCC();
			burn(2);
			break;
		case 0x0d:
			absolute();
			ORA();
			burn(4);
			break;
		case 0x0e:
			absolute();
			ASL();
			burn(6);
			break;
		case 0x0a:
			accumulator();
			ASL();
			burn(2);
			break;
		case 0x99:
			absoluteIndexedY();
			STA();
			burn(5);
			break;
		case 0x98:
			implied();
			TYA();
			burn(2);
			break;
		default:
			PC += 1;
			//throw new Error("Invalid opcode! " + op);
		}
	}
701385
def delete_by_field(self, table: str, field: str, value: Any) -> int:
        """"""
        sql = ("DELETE FROM " + self.delimit(table) +
               " WHERE " + self.delimit(field) + "=?")
        return self.db_exec(sql, value)
939419
def delete_opcode(opcode)
      @chunks = @chunks.inject([]) do |list, chunk|
        list << chunk if chunk.opcode != opcode
        list
      end
      return self
    end
534530
def delete_all(self):
        ''''''
        def delete_action_gen():
            scanner = scan(self.es,
                           index=self.index_name,
                           query={'query': {'match_all':{}}})
            for v in scanner:
                yield { '_op_type': 'delete',
                        '_index': self.index_name,
                        '_type': v['_type'],
                        '_id': v['_id'],
                      }
        bulk(self.es, delete_action_gen())
730613
function concat(list, totalLength) {
  if (list.length === 0) return EMPTY_BUFFER;
  if (list.length === 1) return list[0];

  const target = Buffer.allocUnsafe(totalLength);
  let offset = 0;

  for (let i = 0; i < list.length; i++) {
    const buf = list[i];
    buf.copy(target, offset);
    offset += buf.length;
  }

  return target;
}
542702
def concat(bed_files, catted=None):
    
    bed_files = [x for x in bed_files if x]
    if len(bed_files) == 0:
        if catted:
            # move to a .bed extension for downstream tools if not already
            sorted_bed = catted.sort()
            if not sorted_bed.fn.endswith(".bed"):
                return sorted_bed.moveto(sorted_bed.fn + ".bed")
            else:
                return sorted_bed
        else:
            return catted

    if not catted:
        bed_files = list(bed_files)
        catted = bt.BedTool(bed_files.pop())
    else:
        catted = catted.cat(bed_files.pop(), postmerge=False,
                            force_truncate=False)

    return concat(bed_files, catted)
1229787
function concat () {
  var items = R.dropLast(1, arguments);

  if (!items.length) {
    throw new Error('The helper "concat" must be passed at least one argument.');
  }

  return items.join('');
}
907350
function concatTo(obj, key, val) {
    obj[key] = obj[key] || [];
    obj[key] = obj[key].concat(val);
    return obj[key];
}
616554
function modify( $tpl, $operatorName, $operatorParameters, $rootNamespace, $currentNamespace, &$operatorValue, $namedParameters, $placement )
    {
        $operatorValue = str_replace( "\n",
                                      "<br />",
                                      $operatorValue );
    }
690107
function $concat(params) {
    if (
        Array.isArray(params) &&
        (params.every(p => typeof p === 'string') ||
            params.every(p => Array.isArray(p)))
    ) {
        return params[0].concat(...params.slice(1));
    }
    throw new Error('$concat expects an array of array or string');
}
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
  }