[Demonstration 1]

[Buggy Method]
public void createAndShowGUI() {
    // main contentpanel inicializalsa
    contentPane = new JPanel();
    contentPane.setOpaque(true);
    contentPane.setLayout(new FlowLayout(FlowLayout.LEADING));
    contentPane.setBorder(BorderFactory.createTitledBorder(new TitledBorder(""), Constants.AUTHOR, TitledBorder.TRAILING, TitledBorder.BOTTOM, footerFont, Color.black));
    eSrcFileLbl = new JLabel(Constants.UI_TO_ENC);
    eSrcFileLbl.setFont(standardFont);
    eSrcFileBtn = new JButton(Constants.UI_SELECT);
    eSrcFileBtn.addActionListener(this);
    eDestDirLbl = new JLabel(Constants.UI_SAVE_DIR);
    eDestDirLbl.setFont(standardFont);
    eDestDirBtn = new JButton(Constants.UI_SELECT);
    eDestDirBtn.addActionListener(this);
    eOkBtn = new JButton(Constants.UI_ENCRYPTION);
    eOkBtn.addActionListener(this);
    ePassLbl = new JLabel(Constants.UI_PW);
    ePassLbl.setFont(standardFont);
    ePassInp = new JPasswordField();
    // titkositas panel inicializalasa, es elemek bepakolasa
    encryptionPanel = new JPanel();
    encryptionPanel.setOpaque(true);
    encryptionPanel.setBorder(BorderFactory.createTitledBorder(Constants.UI_ENCRYPTION));
    encryptionPanel.setLayout(new GridLayout(4, 2, 2, 2));
    encryptionPanel.add(eSrcFileLbl);
    encryptionPanel.add(eSrcFileBtn);
    encryptionPanel.add(eDestDirLbl);
    encryptionPanel.add(eDestDirBtn);
    encryptionPanel.add(ePassLbl);
    encryptionPanel.add(ePassInp);
    encryptionPanel.add(placeholder2);
    encryptionPanel.add(eOkBtn);
    dSrcFileLbl = new JLabel(Constants.UI_TO_DEC);
    dSrcFileLbl.setFont(standardFont);
    dSrcFileBtn = new JButton(Constants.UI_SELECT);
    dSrcFileBtn.addActionListener(this);
    dDestDirLbl = new JLabel(Constants.UI_SAVE_DIR);
    dDestDirLbl.setFont(standardFont);
    dDestDirBtn = new JButton(Constants.UI_SELECT);
    dDestDirBtn.addActionListener(this);
    dPassLbl = new JLabel(Constants.UI_PW);
    dPassLbl.setFont(standardFont);
    dPassInp = new JPasswordField();
    dOkBtn = new JButton(Constants.UI_DECRYPTION);
    dOkBtn.addActionListener(this);
    // visszafejtes panel inicializalasa es elemek bepakolasa
    decryptionPanel = new JPanel();
    decryptionPanel.setOpaque(true);
    decryptionPanel.setBorder(BorderFactory.createTitledBorder(Constants.UI_DECRYPTION));
    decryptionPanel.setLayout(new GridLayout(4, 2, 2, 2));
    decryptionPanel.add(dSrcFileLbl);
    decryptionPanel.add(dSrcFileBtn);
    decryptionPanel.add(dDestDirLbl);
    decryptionPanel.add(dDestDirBtn);
    decryptionPanel.add(dPassLbl);
    decryptionPanel.add(dPassInp);
    decryptionPanel.add(placeholder);
    decryptionPanel.add(dOkBtn);
    // hozzadjuk mindket panelt a main content panehez
    contentPane.add(encryptionPanel);
    contentPane.add(decryptionPanel);
    // jframe dolgok
    frame = new JFrame();
    frame.setAutoRequestFocus(true);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setTitle(Constants.APP_NAME);
    frame.setIconImages(loadIcons());
    frame.setContentPane(contentPane);
    frame.pack();
    frame.setResizable(false);
    frame.setLocationRelativeTo(null);
    frame.setVisible(true);
}

[Buggy Hunk]
contentPane.setOpaque(true);

[Patch]
contentPane.setOpaque(!true);

[Demonstration 2]

[Buggy Method]
private boolean resolveAliasFromModule(ClassNode type) {
    // In case of getting a ConstructedClassWithPackage here we do not do checks for partial
    // matches with imported classes. The ConstructedClassWithPackage is already a constructed
    // node and any subclass resolving will then take place elsewhere
    if (type instanceof ConstructedClassWithPackage)
        return false;
    ModuleNode module = currentClass.getModule();
    if (module == null)
        return false;
    String name = type.getName();
    // check module node imports aliases
    // the while loop enables a check for inner classes which are not fully imported,
    // but visible as the surrounding class is imported and the inner class is public/protected static
    String pname = name;
    int index = name.length();
    /*
         * we have a name foo.bar and an import foo.foo. This means foo.bar is possibly
         * foo.foo.bar rather than foo.bar. This means to cut at the dot in foo.bar and
         * foo for import
         */
    while (true) {
        pname = name.substring(0, index);
        ClassNode aliasedNode = null;
        ImportNode importNode = module.getImport(pname);
        if (importNode != null && importNode != currImportNode) {
            aliasedNode = importNode.getType();
        }
        if (aliasedNode == null) {
            importNode = module.getStaticImports().get(pname);
            if (importNode != null && importNode != currImportNode) {
                // static alias only for inner classes and must be at end of chain
                ClassNode tmp = ClassHelper.make(importNode.getType().getName() + "$" + importNode.getFieldName());
                if (resolve(tmp, false, false, true)) {
                    if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) {
                        type.setRedirect(tmp.redirect());
                        return true;
                    }
                }
            }
        }
        if (aliasedNode != null) {
            if (pname.length() == name.length()) {
                // full match
                // We can compare here by length, because pname is always
                // a substring of name, so same length means they are equal.
                type.setRedirect(aliasedNode);
                return true;
            } else {
                //partial match
                // At this point we know that we have a match for pname. This may
                // mean, that name[pname.length()..<-1] is a static inner class.
                // For this the rest of the name does not need any dots in its name.
                // It is either completely a inner static class or it is not.
                // Since we do not want to have useless lookups we create the name
                // completely and use a ConstructedClassWithPackage to prevent lookups against the package.
                String className = aliasedNode.getNameWithoutPackage() + '$' + name.substring(pname.length() + 1).replace('.', '$');
                ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(aliasedNode.getPackageName() + ".", className);
                if (resolve(tmp, true, true, false)) {
                    type.setRedirect(tmp.redirect());
                    return true;
                }
            }
        }
        index = pname.lastIndexOf('.');
        if (index == -1)
            break;
    }
    return false;
}

[Buggy Hunk]
ClassNode tmp = ClassHelper.make(importNode.getType().getName() + "$" + importNode.getFieldName());

[Patch]
ClassNode tmp = new ConstructedNestedClass(importNode.getType(), importNode.getFieldName());

[Demonstration 3]

[Buggy Method]
public void initPrefixes(TwinkqlConfig config) {
    if (config == null) {
        return;
    }
    if (config.getTwinkqlConfigItem() != null) {
        for (TwinkqlConfigItem item : config.getTwinkqlConfigItem()) {
            if (item.getNamespace() != null) {
                this.prefixes.add(this.buildPrefix(item.getNamespace()));
            }
        }
    }
}

[Buggy Hunk]
this.prefixes.add(this.buildPrefix(item.getNamespace()));

[Patch]
this.prefixes.add(item.getNamespace());