nus-yam/ex-repair huggingface dataset:
Program: 35181
Project: 35181
Buggy source:
public boolean addHeader(BlockHeader header){
  lock.lock();
  HeaderDigest hd=new HeaderDigest(header.getPreHash().getDigestHex(),header.getHeight() - 1);
  if (!headerDigestList.isEmpty() && headerDigestList.indexOf(hd) == (headerDigestList.size() - 1)) {
    return false;
  }
  headerDigestList.add(new HeaderDigest(header.getHash().getDigestHex(),header.getHeight()));
  lock.unlock();
  return true;
}

Fixed version (ground truth):
public boolean addHeader(BlockHeader header){
  lock.lock();
  HeaderDigest hd=new HeaderDigest(header.getPreHash().getDigestHex(),header.getHeight() - 1);
  if (!headerDigestList.isEmpty() && headerDigestList.indexOf(hd) != (headerDigestList.size() - 1)) {
    return false;
  }
  headerDigestList.add(new HeaderDigest(header.getHash().getDigestHex(),header.getHeight()));
  lock.unlock();
  return true;
}
Program: 35182
Project: 35182
Buggy source:
public boolean isEncrypted(){
  if (getEncryptedPriKey() != null && getEncryptedPriKey().length > 0) {
    return true;
  }
  return false;
}

Fixed version (ground truth):
public boolean isEncrypted(){
  if (getPriKey() != null && getPriKey().length > 0) {
    return false;
  }
  return true;
}
Program: 35184
Project: 35184
Buggy source:
public static void toBean(AccountPo src,Account desc){
  AssertUtil.canNotEmpty(src,"String_Node_Str");
  AssertUtil.canNotEmpty(desc,"String_Node_Str");
  desc.setCreateTime(src.getCreateTime());
  try {
    desc.setAddress(Address.fromHashs(src.getAddress()));
  }
 catch (  NulsException e) {
    Log.error(e);
  }
  desc.setAlias(src.getAlias());
  desc.setExtend(src.getExtend());
  desc.setPriKey(src.getPriKey());
  desc.setPubKey(src.getPubKey());
  desc.setEncryptedPriKey(src.getEncryptedPriKey());
  desc.setEcKey(ECKey.fromPrivate(new BigInteger(desc.getPriKey())));
  desc.setStatus(src.getStatus());
}

Fixed version (ground truth):
public static void toBean(AccountPo src,Account desc){
  AssertUtil.canNotEmpty(src,"String_Node_Str");
  AssertUtil.canNotEmpty(desc,"String_Node_Str");
  desc.setCreateTime(src.getCreateTime());
  try {
    desc.setAddress(Address.fromHashs(src.getAddress()));
  }
 catch (  NulsException e) {
    Log.error(e);
  }
  desc.setAlias(src.getAlias());
  desc.setExtend(src.getExtend());
  desc.setPriKey(src.getPriKey());
  desc.setPubKey(src.getPubKey());
  desc.setEncryptedPriKey(src.getEncryptedPriKey());
  if (src.getPriKey() != null && src.getPriKey().length > 1) {
    desc.setEcKey(ECKey.fromPrivate(new BigInteger(desc.getPriKey())));
  }
 else {
    desc.setEcKey(ECKey.fromEncrypted(new EncryptedData(src.getEncryptedPriKey()),src.getPubKey()));
  }
  desc.setStatus(src.getStatus());
}
Program: 35185
Project: 35185
Buggy source:
public void init(){
  loadConfigration();
  accountService=NulsContext.getServiceBean(AccountService.class);
  List<Account> list=this.accountService.getAccountList();
  boolean noneAccount=list == null || list.isEmpty();
  if (this.partakePacking && noneAccount) {
    Account account=this.accountService.createAccount("String_Node_Str");
    this.accountService.setDefaultAccount(account.getAddress().getBase58());
    NulsContext.LOCAL_ADDRESS_LIST.add(account.getAddress().getBase58());
  }
  blockCacheManager=BlockCacheManager.getInstance();
  blockCacheManager.init();
  consensusCacheManager=ConsensusCacheManager.getInstance();
  consensusCacheManager.init();
  confirmingTxCacheManager=ConfirmingTxCacheManager.getInstance();
  confirmingTxCacheManager.init();
  receivedTxCacheManager=ReceivedTxCacheManager.getInstance();
  receivedTxCacheManager.init();
  TaskManager.createAndRunThread(NulsConstant.MODULE_ID_CONSENSUS,"String_Node_Str",this);
}

Fixed version (ground truth):
public void init(){
  loadConfigration();
  accountService=NulsContext.getServiceBean(AccountService.class);
  List<Account> list=this.accountService.getAccountList();
  boolean noneAccount=list == null || list.isEmpty();
  if (this.partakePacking && noneAccount) {
    Account account=this.accountService.createAccount(PocConsensusConstant.DEFAULT_WALLET_PASSWORD);
    this.accountService.setDefaultAccount(account.getAddress().getBase58());
    NulsContext.LOCAL_ADDRESS_LIST.add(account.getAddress().getBase58());
  }
  blockCacheManager=BlockCacheManager.getInstance();
  blockCacheManager.init();
  consensusCacheManager=ConsensusCacheManager.getInstance();
  consensusCacheManager.init();
  confirmingTxCacheManager=ConfirmingTxCacheManager.getInstance();
  confirmingTxCacheManager.init();
  receivedTxCacheManager=ReceivedTxCacheManager.getInstance();
  receivedTxCacheManager.init();
  TaskManager.createAndRunThread(NulsConstant.MODULE_ID_CONSENSUS,"String_Node_Str",this);
}
Program: 35186
Project: 35186
Buggy source:
private void yellowPunishTx(Block bestBlock,List<Transaction> txList,PocMeetingMember self){
  BlockRoundData lastBlockRoundData=new BlockRoundData();
  try {
    lastBlockRoundData.parse(bestBlock.getHeader().getExtend());
  }
 catch (  NulsException e) {
    Log.error(e);
  }
  boolean punish=self.getIndexOfRound() == 1 && lastBlockRoundData.getPackingIndexOfRound() != lastBlockRoundData.getConsensusMemberCount();
  punish=punish || (self.getIndexOfRound() > 1 && self.getIndexOfRound() != (lastBlockRoundData.getPackingIndexOfRound() + 1));
  if (!punish) {
    return;
  }
  PocMeetingMember previous=this.consensusManager.getCurrentRound().getMember(self.getIndexOfRound() - 1);
  if (null == previous) {
    return;
  }
  YellowPunishTransaction punishTx=new YellowPunishTransaction();
  YellowPunishData data=new YellowPunishData();
  data.setAddress(previous.getAddress());
  data.setHeight(bestBlock.getHeader().getHeight() + 1);
  punishTx.setTxData(data);
  punishTx.setTime(TimeService.currentTimeMillis());
  punishTx.setFee(Na.ZERO);
  punishTx.setHash(NulsDigestData.calcDigestData(punishTx));
  punishTx.setSign(accountService.signData(punishTx.getHash()));
  txList.add(punishTx);
}

Fixed version (ground truth):
private void yellowPunishTx(Block bestBlock,List<Transaction> txList,PocMeetingMember self){
  BlockRoundData lastBlockRoundData=new BlockRoundData();
  try {
    lastBlockRoundData.parse(bestBlock.getHeader().getExtend());
  }
 catch (  NulsException e) {
    Log.error(e);
  }
  boolean punish=self.getIndexOfRound() == 1 && lastBlockRoundData.getPackingIndexOfRound() != lastBlockRoundData.getConsensusMemberCount();
  punish=punish || (self.getIndexOfRound() > 1 && self.getIndexOfRound() != (lastBlockRoundData.getPackingIndexOfRound() + 1));
  if (!punish) {
    return;
  }
  PocMeetingMember previous=this.consensusManager.getCurrentRound().getMember(self.getIndexOfRound() - 1);
  if (null == previous) {
    return;
  }
  YellowPunishTransaction punishTx=new YellowPunishTransaction();
  YellowPunishData data=new YellowPunishData();
  data.setAddress(previous.getAddress());
  data.setHeight(bestBlock.getHeader().getHeight() + 1);
  punishTx.setTxData(data);
  punishTx.setTime(TimeService.currentTimeMillis());
  punishTx.setFee(Na.ZERO);
  punishTx.setHash(NulsDigestData.calcDigestData(punishTx));
  punishTx.setSign(accountService.signData(punishTx.getHash(),PocConsensusConstant.DEFAULT_WALLET_PASSWORD));
  txList.add(punishTx);
}
Program: 35187
Project: 35187
Buggy source:
private void coinBaseTx(List<Transaction> txList){
  CoinTransferData data=new CoinTransferData();
  data.setFee(Na.ZERO);
  List<ConsensusReward> rewardList=calcReward(txList);
  Na total=Na.ZERO;
  for (  ConsensusReward reward : rewardList) {
    Coin coin=new Coin();
    coin.setNa(reward.getReward());
    data.addTo(reward.getAddress(),coin);
    total=total.add(reward.getReward());
  }
  data.setTotalNa(total);
  CoinBaseTransaction tx=null;
  try {
    tx=new CoinBaseTransaction(data,null);
  }
 catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(e);
  }
  tx.setFee(Na.ZERO);
  tx.setHash(NulsDigestData.calcDigestData(tx));
  tx.setSign(accountService.signData(tx.getHash()));
  ValidateResult validateResult=tx.verify();
  tx.setStatus(TxStatusEnum.AGREED);
  confirmingTxCacheManager.putTx(tx);
  if (null == validateResult || validateResult.isFailed()) {
    throw new NulsRuntimeException(ErrorCode.CONSENSUS_EXCEPTION);
  }
  txList.add(0,tx);
}

Fixed version (ground truth):
private void coinBaseTx(List<Transaction> txList){
  CoinTransferData data=new CoinTransferData();
  data.setFee(Na.ZERO);
  List<ConsensusReward> rewardList=calcReward(txList);
  Na total=Na.ZERO;
  for (  ConsensusReward reward : rewardList) {
    Coin coin=new Coin();
    coin.setNa(reward.getReward());
    data.addTo(reward.getAddress(),coin);
    total=total.add(reward.getReward());
  }
  data.setTotalNa(total);
  CoinBaseTransaction tx=null;
  try {
    tx=new CoinBaseTransaction(data,null);
  }
 catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(e);
  }
  tx.setFee(Na.ZERO);
  tx.setHash(NulsDigestData.calcDigestData(tx));
  tx.setSign(accountService.signData(tx.getHash(),PocConsensusConstant.DEFAULT_WALLET_PASSWORD));
  ValidateResult validateResult=tx.verify();
  tx.setStatus(TxStatusEnum.AGREED);
  confirmingTxCacheManager.putTx(tx);
  if (null == validateResult || validateResult.isFailed()) {
    throw new NulsRuntimeException(ErrorCode.CONSENSUS_EXCEPTION);
  }
  txList.add(0,tx);
}
Program: 35188
Project: 35188
Buggy source:
private void redPunishTx(Block bestBlock,List<Transaction> txList){
  for (  long height : punishMap.keySet()) {
    RedPunishData data=punishMap.get(height);
    punishMap.remove(height);
    if (data.getHeight() < (bestBlock.getHeader().getHeight() + 1)) {
      continue;
    }
    RedPunishTransaction tx=new RedPunishTransaction();
    tx.setTxData(data);
    tx.setTime(TimeService.currentTimeMillis());
    tx.setFee(Na.ZERO);
    tx.setHash(NulsDigestData.calcDigestData(tx));
    tx.setSign(accountService.signData(tx.getHash()));
    txList.add(tx);
  }
}

Fixed version (ground truth):
private void redPunishTx(Block bestBlock,List<Transaction> txList){
  for (  long height : punishMap.keySet()) {
    RedPunishData data=punishMap.get(height);
    punishMap.remove(height);
    if (data.getHeight() < (bestBlock.getHeader().getHeight() + 1)) {
      continue;
    }
    RedPunishTransaction tx=new RedPunishTransaction();
    tx.setTxData(data);
    tx.setTime(TimeService.currentTimeMillis());
    tx.setFee(Na.ZERO);
    tx.setHash(NulsDigestData.calcDigestData(tx));
    tx.setSign(accountService.signData(tx.getHash(),PocConsensusConstant.DEFAULT_WALLET_PASSWORD));
    txList.add(tx);
  }
}
Program: 35189
Project: 35189
Buggy source:
/** 
 * @param packageName
 */
private static void findClassJar(String packageName,String pathName,List<Class> list){
  JarFile jarFile;
  try {
    int index=pathName.indexOf("String_Node_Str");
    if (index > 0) {
      pathName=pathName.substring(0,index);
    }
    URL url=new URL(pathName);
    jarFile=new JarFile(url.getFile());
  }
 catch (  IOException e) {
    throw new RuntimeException("String_Node_Str");
  }
  packageName=packageName.replace("String_Node_Str","String_Node_Str");
  Enumeration<JarEntry> jarEntries=jarFile.entries();
  while (jarEntries.hasMoreElements()) {
    JarEntry jarEntry=jarEntries.nextElement();
    String jarEntryName=jarEntry.getName();
    if (!jarEntryName.contains(packageName) || jarEntryName.equals(packageName + "String_Node_Str")) {
      continue;
    }
    if (jarEntry.isDirectory()) {
      continue;
    }
 else     if (jarEntryName.endsWith(CLASS_TYPE)) {
      Class<?> clazz;
      try {
        String className=jarEntry.getName().replace("String_Node_Str","String_Node_Str").replace(CLASS_TYPE,"String_Node_Str");
        clazz=classLoader.loadClass(className);
      }
 catch (      ClassNotFoundException e) {
        continue;
      }
      list.add(clazz);
    }
  }
}

Fixed version (ground truth):
/** 
 * @param packageName
 */
private static void findClassJar(String packageName,String pathName,List<Class> list){
  if (StringUtils.isBlank(pathName) || list == null) {
    return;
  }
  JarFile jarFile;
  try {
    int index=pathName.indexOf("String_Node_Str");
    if (index > 0) {
      pathName=pathName.substring(0,index);
    }
    URL url=new URL(pathName);
    jarFile=new JarFile(url.getFile());
  }
 catch (  IOException e) {
    throw new RuntimeException("String_Node_Str");
  }
  packageName=packageName.replace("String_Node_Str","String_Node_Str");
  Enumeration<JarEntry> jarEntries=jarFile.entries();
  while (jarEntries.hasMoreElements()) {
    JarEntry jarEntry=jarEntries.nextElement();
    String jarEntryName=jarEntry.getName();
    if (!jarEntryName.contains(packageName) || jarEntryName.equals(packageName + "String_Node_Str")) {
      continue;
    }
    if (jarEntry.isDirectory()) {
      continue;
    }
 else     if (jarEntryName.endsWith(CLASS_TYPE)) {
      Class<?> clazz;
      try {
        String className=jarEntry.getName().replace("String_Node_Str","String_Node_Str").replace(CLASS_TYPE,"String_Node_Str");
        clazz=classLoader.loadClass(className);
      }
 catch (      ClassNotFoundException e) {
        continue;
      }
      list.add(clazz);
    }
  }
}
Program: 35190
Project: 35190
Buggy source:
public static List<Class> scan(final String packageName){
  List<Class> list=new ArrayList<>();
  Enumeration<URL> dirs;
  try {
    dirs=Thread.currentThread().getContextClassLoader().getResources(packageName.replace("String_Node_Str","String_Node_Str"));
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
  if (null == dirs) {
    return list;
  }
  while (dirs.hasMoreElements()) {
    URL url=dirs.nextElement();
    String protocol=url.getProtocol();
    if (FILE_TYPE.equals(protocol)) {
      findClassLocal(packageName,url.getPath(),list);
    }
 else     if (JAR_TYPE.equals(protocol)) {
      findClassJar(packageName,url.getPath(),list);
    }
  }
  return list;
}

Fixed version (ground truth):
public static List<Class> scan(String packageName){
  if (StringUtils.isBlank(packageName)) {
    packageName="String_Node_Str";
  }
  List<Class> list=new ArrayList<>();
  Enumeration<URL> dirs;
  try {
    dirs=Thread.currentThread().getContextClassLoader().getResources(packageName.replace("String_Node_Str","String_Node_Str"));
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
  if (null == dirs) {
    return list;
  }
  while (dirs.hasMoreElements()) {
    URL url=dirs.nextElement();
    String protocol=url.getProtocol();
    if (FILE_TYPE.equals(protocol)) {
      findClassLocal(packageName,url.getPath(),list);
    }
 else     if (JAR_TYPE.equals(protocol)) {
      findClassJar(packageName,url.getPath(),list);
    }
  }
  return list;
}
Program: 35191
Project: 35191
Buggy source:
public static void start(){
  List<NulsVersion> versionList=NulsContext.getServiceBeanList(NulsVersion.class);
}

Fixed version (ground truth):
public static void start(){
  NulsContext.NEWEST_VERSION="String_Node_Str";
  NulsContext.VERSION="String_Node_Str";
  List<NulsVersion> versionList=NulsContext.getServiceBeanList(NulsVersion.class);
}
Program: 35192
Project: 35192
Buggy source:
public boolean addHeader(BlockHeader header){
  lock.lock();
  if (!headerDigestList.isEmpty() && !headerDigestList.get(headerDigestList.size() - 1).getHash().equals(header.getPreHash().getDigestHex())) {
    return false;
  }
  headerDigestList.add(new HeaderDigest(header.getHash().getDigestHex(),header.getHeight()));
  lock.unlock();
  return true;
}

Fixed version (ground truth):
public boolean addHeader(BlockHeader header){
  lock.lock();
  HeaderDigest hd=new HeaderDigest(header.getPreHash().getDigestHex(),header.getHeight() - 1);
  if (!headerDigestList.isEmpty() && headerDigestList.indexOf(hd) == (headerDigestList.size() - 1)) {
    return false;
  }
  headerDigestList.add(new HeaderDigest(header.getHash().getDigestHex(),header.getHeight()));
  lock.unlock();
  return true;
}
Program: 35194
Project: 35194
Buggy source:
public Map<String,Coin> getToMap(){
  return toMap;
}

Fixed version (ground truth):
public Map<String,List<Coin>> getToMap(){
  return toMap;
}
Program: 35195
Project: 35195
Buggy source:
public void addTo(String address,Coin coin){
  this.toMap.put(address,coin);
}

Fixed version (ground truth):
public void addTo(String address,Coin coin){
  List<Coin> coinList=toMap.get(address);
  if (null == coinList) {
    coinList=new ArrayList<>();
  }
  coinList.add(coin);
  this.toMap.put(address,coinList);
}
Program: 35196
Project: 35196
Buggy source:
public void setToMap(Map<String,Coin> toMap){
  this.toMap=toMap;
}

Fixed version (ground truth):
public void setToMap(Map<String,List<Coin>> toMap){
  this.toMap=toMap;
}
Program: 35197
Project: 35197
Buggy source:
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(new NulsVersion((short)0));
    account.setAddress(address);
    account.setId(address.toString());
    account.setPubKey(key.getPubKey(true));
    account.setEcKey(key);
    account.setPriKey(key.getPrivKeyBytes());
    account.setCreateTime(TimeService.currentTimeMillis());
    account.setTxHash(new NulsDigestData());
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}

Fixed version (ground truth):
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(new NulsVersion((short)0));
    account.setAddress(address);
    account.setId(address.toString());
    account.setPubKey(key.getPubKey(true));
    account.setEcKey(key);
    account.setPriKey(key.getPrivKeyBytes());
    account.setCreateTime(TimeService.currentTimeMillis());
    account.setTxHash(new NulsDigestData(new byte[]{0}));
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}
Program: 35198
Project: 35198
Buggy source:
private NulsContext(){
  CHAIN_ID="String_Node_Str";
}

Fixed version (ground truth):
private NulsContext(){
  CHAIN_ID="String_Node_Str";
  chain_id_map.put(CHAIN_ID,1);
}
Program: 35199
Project: 35199
Buggy source:
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(new NulsVersion((short)0));
    account.setAddress(address);
    account.setId(address.toString());
    account.setPubKey(key.getPubKey(true));
    account.setEcKey(key);
    account.setPriKey(key.getPrivKeyBytes());
    account.setCreateTime(TimeService.currentTimeMillis());
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}

Fixed version (ground truth):
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(new NulsVersion((short)0));
    account.setAddress(address);
    account.setId(address.toString());
    account.setPubKey(key.getPubKey(true));
    account.setEcKey(key);
    account.setPriKey(key.getPrivKeyBytes());
    account.setCreateTime(TimeService.currentTimeMillis());
    account.setTxHash(new NulsDigestData());
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}
Program: 35200
Project: 35200
Buggy source:
@Override public List<Account> getLocalAccountList(){
  List<Account> list=this.accountCacheService.getAccountList();
  if (null != list && !list.isEmpty()) {
    return list;
  }
  list=new ArrayList<>();
  List<AccountPo> polist=this.accountDao.listAll();
  if (null == polist || polist.isEmpty()) {
    return list;
  }
  for (  AccountPo po : polist) {
    Account account=new Account();
    AccountTool.toBean(po,account);
    list.add(account);
  }
  this.accountCacheService.putAccountList(list);
  return list;
}

Fixed version (ground truth):
@Override public List<Account> getLocalAccountList(){
  List<Account> list=this.accountCacheService.getAccountList();
  if (null != list && !list.isEmpty()) {
    return list;
  }
  list=new ArrayList<>();
  List<AccountPo> polist=this.accountDao.queryAll();
  if (null == polist || polist.isEmpty()) {
    return list;
  }
  for (  AccountPo po : polist) {
    Account account=new Account();
    AccountTool.toBean(po,account);
    list.add(account);
  }
  this.accountCacheService.putAccountList(list);
  return list;
}
Program: 35201
Project: 35201
Buggy source:
@Test public void testCount(){
  Long count=blockDao.count();
  Log.info("String_Node_Str" + count);
}

Fixed version (ground truth):
@Test public void testCount(){
  Long count=blockDao.getCount();
  Log.info("String_Node_Str" + count);
}
Program: 35202
Project: 35202
Buggy source:
public ConnectionManager(NetworkModule module,NetworkParam network){
  this.network=network;
  this.networkModule=module;
  lock=new ReentrantLock();
  init();
}

Fixed version (ground truth):
public ConnectionManager(AbstractNetworkModule module,AbstractNetworkParam network){
  this.network=network;
  this.networkModule=module;
  lock=new ReentrantLock();
  init();
}
Program: 35204
Project: 35204
Buggy source:
public void start(){
  new NulsThread(networkModule,"String_Node_Str"){
    @Override public void run(){
      ConnectionManager.this.run();
    }
  }
.start();
}

Fixed version (ground truth):
public void start(){
  new BaseNulsThread(networkModule,"String_Node_Str"){
    @Override public void run(){
      ConnectionManager.this.run();
    }
  }
.start();
}
Program: 35205
Project: 35205
Buggy source:
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(AccountConstant.ACCOUNT_MODULE_VERSION);
    account.setAddress(address);
    account.setPubKey(key.getPubKey(true));
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    account.setEcKey(key);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}

Fixed version (ground truth):
@Override public Account createAccount(){
  locker.lock();
  try {
    ECKey key=new ECKey();
    Address address=new Address(Utils.sha256hash160(key.getPubKey(false)));
    Account account=new Account();
    account.setPriSeed(key.getPrivKeyBytes());
    account.setVersion(AccountConstant.ACCOUNT_MODULE_VERSION);
    account.setAddress(address);
    account.setId(address.toString());
    account.setPubKey(key.getPubKey(true));
    account.setEcKey(key);
    account.setPriKey(key.getPrivKeyBytes());
    signAccount(account);
    AccountPo po=new AccountPo();
    AccountTool.toPojo(account,po);
    this.accountDao.save(po);
    this.accountCacheService.putAccount(account);
    return account;
  }
 catch (  IOException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
catch (  NulsException e) {
    Log.error(e);
    throw new NulsRuntimeException(ErrorCode.FAILED,"String_Node_Str");
  }
 finally {
    locker.unlock();
  }
}
Program: 35206
Project: 35206
Buggy source:
@Override public int size(){
  int s=0;
  s+=VarInt.sizeOf(version);
  if (!StringUtils.isBlank(id)) {
    try {
      s+=id.getBytes(NulsContext.DEFAULT_ENCODING).length + 1;
    }
 catch (    UnsupportedEncodingException e) {
      Log.error(e);
    }
  }
 else {
    s++;
  }
  if (StringUtils.isNotBlank(alias)) {
    try {
      s+=alias.getBytes(NulsContext.DEFAULT_ENCODING).length + 1;
    }
 catch (    UnsupportedEncodingException e) {
      Log.error(e);
    }
  }
 else {
    s++;
  }
  if (null != address) {
    s+=address.getHash160().length;
  }
  if (null != priSeed) {
    s+=priSeed.length + 1;
  }
  s+=1;
  if (null != sign) {
    s+=sign.length + 1;
  }
  s+=pubKey.length + 1;
  s+=extend.length + 1;
  return s;
}

Fixed version (ground truth):
@Override public int size(){
  int s=0;
  s+=VarInt.sizeOf(version);
  if (!StringUtils.isBlank(id)) {
    try {
      s+=id.getBytes(NulsContext.DEFAULT_ENCODING).length + 1;
    }
 catch (    UnsupportedEncodingException e) {
      Log.error(e);
    }
  }
 else {
    s++;
  }
  if (StringUtils.isNotBlank(alias)) {
    try {
      s+=alias.getBytes(NulsContext.DEFAULT_ENCODING).length + 1;
    }
 catch (    UnsupportedEncodingException e) {
      Log.error(e);
    }
  }
 else {
    s++;
  }
  if (null != address) {
    s+=address.getHash160().length;
  }
  if (null != priSeed) {
    s+=priSeed.length + 1;
  }
  s+=1;
  if (null != sign) {
    s+=sign.length + 1;
  }
  s+=pubKey.length + 1;
  if (null != extend) {
    s+=extend.length + 1;
  }
  return s;
}
Program: 35207
Project: 35207
Buggy source:
@Override public List<T> getElementValueList(String cacheTitle){
  Iterator it=cacheManager.getCache(cacheTitle).iterator();
  List<T> list=new ArrayList<>();
  while (it.hasNext()) {
    T t=(T)it.next();
    list.add(t);
  }
  return list;
}

Fixed version (ground truth):
@Override public List<T> getElementValueList(String cacheTitle){
  Iterator it=cacheManager.getCache(cacheTitle).iterator();
  List<T> list=new ArrayList<>();
  while (it.hasNext()) {
    Cache.Entry<K,T> entry=(Cache.Entry<K,T>)it.next();
    list.add(entry.getValue());
  }
  return list;
}
Program: 35208
Project: 35208
Buggy source:
public void actionPerformed(ActionEvent e){
  try {
    TryCatchBlockNode tcbn=new TryCatchBlockNode(null,null,null,null);
    if (new InsnEditDialogue(mn,tcbn).open())     if (tcbn.handler != null && tcbn.start != null && tcbn.end != null) {
      if (tcbn.type != null && tcbn.type.equals("String_Node_Str")) {
        tcbn.type=null;
      }
      mn.tryCatchBlocks.add(tcbn);
    }
  }
 catch (  Exception ex) {
    new ErrorDisplay(ex);
  }
  TCBList.this.addNodes(cn,mn);
}

Fixed version (ground truth):
public void actionPerformed(ActionEvent e){
  try {
    TryCatchBlockNode tcbn=new TryCatchBlockNode(null,null,null,"String_Node_Str");
    if (new InsnEditDialogue(mn,tcbn).open())     if (tcbn.handler != null && tcbn.start != null && tcbn.end != null) {
      if (tcbn.type != null && tcbn.type.equals("String_Node_Str")) {
        tcbn.type=null;
      }
      mn.tryCatchBlocks.add(tcbn);
    }
  }
 catch (  Exception ex) {
    new ErrorDisplay(ex);
  }
  TCBList.this.addNodes(cn,mn);
}
Program: 35211
Project: 35211
Buggy source:
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public HashMap<AbstractInsnNode,Mistake> findErrors(){
  HashMap<AbstractInsnNode,Mistake> map=new HashMap<>();
  for (  AbstractInsnNode ain : mn.instructions.toArray()) {
    maxLocals(mn.maxLocals,ain,map);
  }
  final Analyzer a=new Analyzer(new BasicVerifier());
  try {
    a.analyze(mn.owner,mn);
  }
 catch (  AnalyzerException e) {
    put(map,e.node,new InsnError(e.getMessage()));
  }
catch (  Exception e) {
    JByteMod.LOGGER.err("String_Node_Str" + e.toString() + "String_Node_Str");
  }
  return map;
}

Fixed version (ground truth):
@SuppressWarnings({"String_Node_Str","String_Node_Str"}) public HashMap<AbstractInsnNode,Mistake> findErrors(){
  HashMap<AbstractInsnNode,Mistake> map=new HashMap<>();
  for (  AbstractInsnNode ain : mn.instructions.toArray()) {
    maxLocals(mn.maxLocals,ain,map);
  }
  final Analyzer a=new Analyzer(new BasicVerifier());
  try {
    a.analyze(cn.name,mn);
  }
 catch (  AnalyzerException e) {
    put(map,e.node,new InsnError(e.getMessage()));
  }
catch (  Exception e) {
    JByteMod.LOGGER.err("String_Node_Str" + e.toString() + "String_Node_Str");
  }
  return map;
}
Program: 35212
Project: 35212
Buggy source:
public ErrorAnalyzer(MethodNode mn){
  this.mn=mn;
}

Fixed version (ground truth):
public ErrorAnalyzer(ClassNode cn,MethodNode mn){
  this.cn=cn;
  this.mn=mn;
}
Program: 35215
Project: 35215
Buggy source:
public void setAccess(int accezz){
  this.accezz=accezz;
  visibility.updateVisibility(accezz);
  extras.updateVisibility(accezz);
  other.updateVisibility(accezz);
}

Fixed version (ground truth):
public void setAccess(int accezz){
  visibility.updateVisibility(accezz);
  extras.updateVisibility(accezz);
  other.updateVisibility(accezz);
}
Program: 35216
Project: 35216
Buggy source:
public void updateVisibility(int access){
  visibility=0;
  for (  int acc : otherTypes.values()) {
    if ((access & acc) != 0) {
      visibility|=acc;
    }
  }
  this.setText("String_Node_Str");
}

Fixed version (ground truth):
public void updateVisibility(int access){
  visibility=0;
  for (  int acc : otherTypes.values()) {
    if ((access & acc) != 0) {
      visibility|=acc;
    }
  }
  this.setText("String_Node_Str");
  if (label != null)   label.setText(String.valueOf(getAccess()));
}
Program: 35217
Project: 35217
Buggy source:
public OtherButton(int access){
  updateVisibility(access);
  this.addMouseListener(new MouseAdapter(){
    public void mouseClicked(    MouseEvent e){
      WebButtonPopup popupMenu=generatePopupMenu();
      popupMenu.showPopup();
    }
  }
);
}

Fixed version (ground truth):
public OtherButton(int access){
  try {
    for (    Field d : Opcodes.class.getDeclaredFields()) {
      if (d.getName().startsWith("String_Node_Str") && !alreadyCovered.contains(d.getName())) {
        int acc=d.getInt(null);
        otherTypes.put(d.getName().substring(4).toLowerCase(),acc);
      }
    }
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
  updateVisibility(access);
  this.addMouseListener(new MouseAdapter(){
    public void mouseClicked(    MouseEvent e){
      WebButtonPopup popupMenu=generatePopupMenu();
      popupMenu.showPopup();
    }
  }
);
}
Program: 35218
Project: 35218
Buggy source:
public JAccessSelectorPanel(int accezz){
  this.accezz=accezz;
  this.setLayout(new GridLayout(1,4));
  this.add(visibility=new VisibilityButton(accezz));
  this.add(extras=new ExtrasButton(accezz));
  this.add(other=new OtherButton(accezz));
  this.add(new JLabel("String_Node_Str"));
}

Fixed version (ground truth):
public JAccessSelectorPanel(int accezz){
  this.setLayout(new GridLayout(1,4));
  this.add(visibility=new VisibilityButton(accezz));
  this.add(extras=new ExtrasButton(accezz));
  this.add(other=new OtherButton(accezz));
  this.add(label=new JLabel(String.valueOf(accezz)));
}
Program: 35219
Project: 35219
Buggy source:
@Override protected boolean ignore(String name){
  return name.equals("String_Node_Str") || name.toLowerCase().contains("String_Node_Str") || name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str");
}

Fixed version (ground truth):
@Override protected boolean ignore(String name){
  return name.equals("String_Node_Str") || name.toLowerCase().contains("String_Node_Str") || name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str")|| name.equals("String_Node_Str");
}
Program: 35220
Project: 35220
Buggy source:
private void readXML(Map<String,String> m,InputStream is){
  try {
    DocumentBuilderFactory dbFactory=DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder=dbFactory.newDocumentBuilder();
    Document doc=dBuilder.parse(is);
    doc.getDocumentElement().normalize();
    Element resources=doc.getDocumentElement();
    NodeList nodes=resources.getChildNodes();
    for (int i=0; i < nodes.getLength(); i++) {
      Node e=(Node)nodes.item(i);
      if (e.getNodeName().equals("String_Node_Str")) {
        Element el=(Element)e;
        m.put(el.getAttribute("String_Node_Str"),e.getTextContent());
      }
    }
  }
 catch (  Exception e) {
    new ErrorDisplay(e);
    JByteMod.LOGGER.err("String_Node_Str" + e.getMessage());
  }
}

Fixed version (ground truth):
private void readXML(Map<String,String> m,InputStream is){
  try {
    DocumentBuilderFactory dbFactory=DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder=dbFactory.newDocumentBuilder();
    Document doc=dBuilder.parse(is);
    doc.getDocumentElement().normalize();
    Element resources=doc.getDocumentElement();
    NodeList nodes=resources.getChildNodes();
    for (int i=0; i < nodes.getLength(); i++) {
      Node e=(Node)nodes.item(i);
      if (e.getNodeName().equals("String_Node_Str")) {
        Element el=(Element)e;
        m.put(el.getAttribute("String_Node_Str"),e.getTextContent());
      }
    }
  }
 catch (  Exception e) {
    JByteMod.LOGGER.err("String_Node_Str" + e.getMessage());
    e.printStackTrace();
    new ErrorDisplay(e);
  }
}
Program: 35221
Project: 35221
Buggy source:
private void _init_(String title,String s){
  this.setBounds(100,100,400,600);
  this.setTitle(title);
  JPanel contentPane=new JPanel();
  contentPane.setBorder(new EmptyBorder(5,5,5,5));
  contentPane.setLayout(new BorderLayout(5,5));
  JPanel pageEnd=new JPanel();
  pageEnd.setLayout(new GridLayout(1,6,10,10));
  contentPane.add(pageEnd,BorderLayout.PAGE_END);
  for (int i=0; i < 4; i++) {
    pageEnd.add(new JPanel());
  }
  JButton close=new JButton(JByteMod.res.getResource("String_Node_Str"));
  pageEnd.add(close);
  close.addActionListener(new ActionListener(){
    @Override public void actionPerformed(    ActionEvent e){
      ErrorDisplay.this.dispose();
    }
  }
);
  String st=s + suffix;
  contentPane.add(new JScrollPane(new JTextArea(st)),BorderLayout.CENTER);
  this.add(contentPane);
  this.setVisible(true);
}

Fixed version (ground truth):
private void _init_(String title,String s){
  this.setBounds(100,100,400,600);
  this.setTitle(title);
  JPanel contentPane=new JPanel();
  contentPane.setBorder(new EmptyBorder(5,5,5,5));
  contentPane.setLayout(new BorderLayout(5,5));
  JPanel pageEnd=new JPanel();
  pageEnd.setLayout(new GridLayout(1,6,10,10));
  contentPane.add(pageEnd,BorderLayout.PAGE_END);
  for (int i=0; i < 4; i++) {
    pageEnd.add(new JPanel());
  }
  JButton close=new JButton(JByteMod.res != null ? JByteMod.res.getResource("String_Node_Str") : "String_Node_Str");
  pageEnd.add(close);
  close.addActionListener(new ActionListener(){
    @Override public void actionPerformed(    ActionEvent e){
      ErrorDisplay.this.dispose();
    }
  }
);
  String st=s + suffix;
  contentPane.add(new JScrollPane(new JTextArea(st)),BorderLayout.CENTER);
  this.add(contentPane);
  this.setVisible(true);
}
Program: 35223
Project: 35223
Buggy source:
private void simplifyBlock(ArrayList<Block> simplified,ArrayList<Block> blocks,Block b){
  if (simplified.contains(b)) {
    return;
  }
  simplified.add(b);
  while (true) {
    if (b.getOutput().size() == 1) {
      Block to=b.getOutput().get(0);
      if (to.getInput().size() == 1) {
        assert(to.getInput().get(0) == b);
        b.getNodes().addAll(to.getNodes());
        b.setEndNode(to.getEndNode());
        b.setOutput(to.getOutput());
        blocks.remove(to);
        continue;
      }
    }
    break;
  }
  for (  Block output : b.getOutput()) {
    simplifyBlock(simplified,blocks,output);
  }
}

Fixed version (ground truth):
private void simplifyBlock(ArrayList<Block> simplified,ArrayList<Block> blocks,Block b){
  if (simplified.contains(b)) {
    return;
  }
  simplified.add(b);
  while (true) {
    if (b.getOutput().size() == 1) {
      Block to=b.getOutput().get(0);
      if (to.getInput().size() == 1 && !isFirst(to)) {
        assert(to.getInput().get(0) == b);
        b.getNodes().addAll(to.getNodes());
        b.setEndNode(to.getEndNode());
        b.setOutput(to.getOutput());
        blocks.remove(to);
        continue;
      }
    }
    break;
  }
  for (  Block output : b.getOutput()) {
    simplifyBlock(simplified,blocks,output);
  }
}
Program: 35224
Project: 35224
Buggy source:
public void generateList(){
  if (node == null)   return;
  cf.clear();
  if (node.instructions.size() == 0) {
    this.clear();
    return;
  }
  Converter c=new Converter(node);
  try {
    cf.addAll(c.convert(JByteMod.ops.get("String_Node_Str").getBoolean(),JByteMod.ops.get("String_Node_Str").getBoolean()));
  }
 catch (  Exception e) {
    e.printStackTrace();
    new ErrorDisplay(e);
    this.clear();
    return;
  }
  Object parent=graph.getDefaultParent();
  graph.getModel().beginUpdate();
  try {
    graph.removeCells(graph.getChildCells(graph.getDefaultParent(),true,true));
    existing.clear();
    if (!cf.isEmpty()) {
      for (      Block b : cf) {
        if (b.getInput().isEmpty()) {
          addBlock(parent,b);
        }
      }
    }
    mxHierarchicalLayout layout=new mxHierarchicalLayout(graph);
    layout.setFineTuning(true);
    layout.setIntraCellSpacing(25d);
    layout.setInterRankCellSpacing(80d);
    layout.execute(graph.getDefaultParent());
  }
  finally {
    graph.getModel().endUpdate();
  }
  this.repaint();
}

Fixed version (ground truth):
public void generateList(){
  if (node == null)   return;
  cf.clear();
  if (node.instructions.size() == 0) {
    this.clear();
    return;
  }
  Converter c=new Converter(node);
  try {
    cf.addAll(c.convert(JByteMod.ops.get("String_Node_Str").getBoolean(),JByteMod.ops.get("String_Node_Str").getBoolean()));
  }
 catch (  Exception e) {
    e.printStackTrace();
    new ErrorDisplay(e);
    this.clear();
    return;
  }
  Object parent=graph.getDefaultParent();
  graph.getModel().beginUpdate();
  try {
    graph.removeCells(graph.getChildCells(graph.getDefaultParent(),true,true));
    existing.clear();
    if (!cf.isEmpty()) {
      boolean first=true;
      for (      Block b : cf) {
        if (b.getInput().isEmpty() || first) {
          addBlock(parent,b);
          first=false;
        }
      }
    }
    mxHierarchicalLayout layout=new mxHierarchicalLayout(graph);
    layout.setFineTuning(true);
    layout.setIntraCellSpacing(25d);
    layout.setInterRankCellSpacing(80d);
    layout.execute(graph.getDefaultParent());
  }
  finally {
    graph.getModel().endUpdate();
  }
  this.repaint();
}
Program: 35226
Project: 35226
Buggy source:
public void selectClass(ClassNode cn){
  this.currentNode=cn;
  sp.selectClass(cn);
  clist.loadFields(cn);
  tabbedPane.selectClass(cn);
  lastSelectedEntries.put(cn,null);
  if (lastSelectedEntries.size() > 5) {
    lastSelectedEntries.remove(lastSelectedEntries.keySet().iterator().next());
  }
}

Fixed version (ground truth):
public void selectClass(ClassNode cn){
  this.currentNode=cn;
  sp.selectClass(cn);
  clist.loadFields(cn);
  tabbedPane.selectClass(cn);
  lastSelectedTreeEntries.put(cn,null);
  if (lastSelectedTreeEntries.size() > 5) {
    lastSelectedTreeEntries.remove(lastSelectedTreeEntries.keySet().iterator().next());
  }
}
Program: 35227
Project: 35227
Buggy source:
public void treeSelection(ClassNode cn,MethodNode mn){
  new Thread(() -> {
    DefaultTreeModel tm=(DefaultTreeModel)jarTree.getModel();
    this.selectEntry(mn,tm,(SortedTreeNode)tm.getRoot());
  }
).start();
}

Fixed version (ground truth):
public void treeSelection(ClassNode cn,MethodNode mn){
  new Thread(() -> {
    DefaultTreeModel tm=(DefaultTreeModel)jarTree.getModel();
    if (this.selectEntry(mn,tm,(SortedTreeNode)tm.getRoot())) {
      jarTree.repaint();
    }
  }
).start();
}
Program: 35228
Project: 35228
Buggy source:
public void selectMethod(ClassNode cn,MethodNode mn){
  OpUtils.clearLabelCache();
  this.currentNode=cn;
  this.currentMethod=mn;
  sp.selectMethod(cn,mn);
  if (!clist.loadInstructions(mn)) {
    clist.setSelectedIndex(-1);
  }
  tcblist.addNodes(cn,mn);
  lvplist.addNodes(cn,mn);
  cfp.setNode(mn);
  dp.setText("String_Node_Str");
  tabbedPane.selectMethod(cn,mn);
  lastSelectedEntries.put(cn,mn);
  if (lastSelectedEntries.size() > 5) {
    lastSelectedEntries.remove(lastSelectedEntries.keySet().iterator().next());
  }
}

Fixed version (ground truth):
public void selectMethod(ClassNode cn,MethodNode mn){
  OpUtils.clearLabelCache();
  this.currentNode=cn;
  this.currentMethod=mn;
  sp.selectMethod(cn,mn);
  if (!clist.loadInstructions(mn)) {
    clist.setSelectedIndex(-1);
  }
  tcblist.addNodes(cn,mn);
  lvplist.addNodes(cn,mn);
  cfp.setNode(mn);
  dp.setText("String_Node_Str");
  tabbedPane.selectMethod(cn,mn);
  lastSelectedTreeEntries.put(cn,mn);
  if (lastSelectedTreeEntries.size() > 5) {
    lastSelectedTreeEntries.remove(lastSelectedTreeEntries.keySet().iterator().next());
  }
}
Program: 35229
Project: 35229
Buggy source:
/** 
 * Load .jar or .class file
 */
public void loadFile(File input){
  String ap=input.getAbsolutePath();
  if (ap.endsWith("String_Node_Str")) {
    try {
      this.file=new JarArchive(this,input);
    }
 catch (    Throwable e) {
      new ErrorDisplay(e);
    }
  }
 else   if (ap.endsWith("String_Node_Str")) {
    try {
      this.file=new JarArchive(ASMUtils.getNode(Files.readAllBytes(input.toPath())));
      this.refreshTree();
    }
 catch (    Throwable e) {
      new ErrorDisplay(e);
    }
  }
 else {
    new ErrorDisplay(new UnsupportedOperationException(res.getResource("String_Node_Str")));
  }
  for (  Plugin p : pluginManager.getPlugins()) {
    p.loadFile(file.getClasses());
  }
}

Fixed version (ground truth):
/** 
 * Load .jar or .class file
 */
public void loadFile(File input){
  String ap=input.getAbsolutePath();
  if (ap.endsWith("String_Node_Str")) {
    try {
      file=new JarArchive(this,input);
    }
 catch (    Throwable e) {
      new ErrorDisplay(e);
    }
  }
 else   if (ap.endsWith("String_Node_Str")) {
    try {
      file=new JarArchive(ASMUtils.getNode(Files.readAllBytes(input.toPath())));
      this.refreshTree();
    }
 catch (    Throwable e) {
      new ErrorDisplay(e);
    }
  }
 else {
    new ErrorDisplay(new UnsupportedOperationException(res.getResource("String_Node_Str")));
  }
  for (  Plugin p : pluginManager.getPlugins()) {
    p.loadFile(file.getClasses());
  }
}
Program: 35230
Project: 35230
Buggy source:
public PluginManager(JByteMod jbm){
  this.jbm=jbm;
  if (pluginFolder.exists() && pluginFolder.isDirectory()) {
    loadPlugins();
  }
 else {
    System.err.println("String_Node_Str");
  }
}

Fixed version (ground truth):
public PluginManager(JByteMod jbm){
  if (pluginFolder.exists() && pluginFolder.isDirectory()) {
    loadPlugins();
  }
 else {
    System.err.println("String_Node_Str");
  }
}
Program: 35231
Project: 35231
Buggy source:
public void changedChilds(TreeNode node){
  model.nodeChanged(node);
  if (node.getChildCount() >= 0) {
    for (Enumeration e=node.children(); e.hasMoreElements(); ) {
      TreeNode n=(TreeNode)e.nextElement();
      changedChilds(n);
    }
  }
}

Fixed version (ground truth):
public void changedChilds(TreeNode node){
  model.nodeChanged(node);
  if (node.getChildCount() >= 0) {
    for (Enumeration<?> e=node.children(); e.hasMoreElements(); ) {
      TreeNode n=(TreeNode)e.nextElement();
      changedChilds(n);
    }
  }
}
Program: 35232
Project: 35232
Buggy source:
public ControlFlowPanel(){
  this.setBorder(new EmptyBorder(30,30,30,30));
  this.setLayout(new BorderLayout(0,0));
  this.setBackground(Color.WHITE);
  graph=new mxGraph();
  graph.setAutoOrigin(true);
  graph.setAutoSizeCells(true);
  graph.setHtmlLabels(true);
  setStyles();
  graphComponent=new mxGraphComponent(graph);
  graphComponent.setEnabled(false);
  graphComponent.setBorder(new EmptyBorder(0,0,0,0));
  this.add(graphComponent,BorderLayout.CENTER);
}

Fixed version (ground truth):
public ControlFlowPanel(){
  this.setBorder(new EmptyBorder(30,30,30,30));
  this.setLayout(new BorderLayout(0,0));
  this.setBackground(Color.WHITE);
  graph=new mxGraph();
  graph.setAutoOrigin(true);
  graph.setAutoSizeCells(true);
  graph.setHtmlLabels(true);
  setStyles();
  graphComponent=new mxGraphComponent(graph);
  graphComponent.getViewport().setBackground(Color.WHITE);
  graphComponent.setEnabled(false);
  graphComponent.setBorder(new EmptyBorder(0,0,0,0));
  this.add(graphComponent,BorderLayout.CENTER);
}
Program: 35234
Project: 35234
Buggy source:
public MySplitPane(JByteMod jam,ClassTree dexTree){
  rightSide=new MyTabbedPane(jam);
  leftSide=new JPanel();
  leftSide.setLayout(new BorderLayout(0,0));
  leftSide.add(new JLabel("String_Node_Str"),BorderLayout.NORTH);
  leftSide.add(new JScrollPane(dexTree),BorderLayout.CENTER);
  JPanel border=new JPanel();
  border.setBorder(new LineBorder(JByteMod.border));
  border.setLayout(new GridLayout());
  this.setLeftComponent(leftSide);
  this.setRightComponent(rightSide);
  this.setDividerLocation(150);
  this.setContinuousLayout(true);
}

Fixed version (ground truth):
public MySplitPane(JByteMod jbm,ClassTree classTree){
  rightSide=new MyTabbedPane(jbm);
  leftSide=new JPanel();
  leftSide.setLayout(new BorderLayout(0,0));
  leftSide.add(new JLabel("String_Node_Str"),BorderLayout.NORTH);
  leftSide.add(new JScrollPane(classTree),BorderLayout.CENTER);
  this.setLeftComponent(leftSide);
  this.setRightComponent(rightSide);
  this.setDividerLocation(150);
  this.setContinuousLayout(true);
}