class StructureResonanceGenerator {

    public IAtomContainerSet getContainers(IAtomContainer molecule) {
        IAtomContainerSet setOfCont = molecule.getBuilder().newInstance(IAtomContainerSet.class);
        IAtomContainerSet setOfMol = getStructures(molecule);

        if (setOfMol.getAtomContainerCount() == 0) return setOfCont;

        /* extraction of all bonds which has been produced a changes of order */
        List<IBond> bondList = new ArrayList<IBond>();
        for (int i = 1; i < setOfMol.getAtomContainerCount(); i++) {
            IAtomContainer mol = setOfMol.getAtomContainer(i);
            for (int j = 0; j < mol.getBondCount(); j++) {
                IBond bond = molecule.getBond(j);
                if (!mol.getBond(j).getOrder().equals(bond.getOrder())) {
                    if (!bondList.contains(bond)) bondList.add(bond);
                }
            }
        }

        if (bondList.size() == 0) return null;

        int[] flagBelonging = new int[bondList.size()];
        for (int i = 0; i < flagBelonging.length; i++)
            flagBelonging[i] = 0;
        int[] position = new int[bondList.size()];
        int maxGroup = 1;

        /* Analysis if the bond are linked together */
        List<IBond> newBondList = new ArrayList<IBond>();
        newBondList.add(bondList.get(0));

        int pos = 0;
        for (int i = 0; i < newBondList.size(); i++) {

            if (i == 0)
                flagBelonging[i] = maxGroup;
            else {
                if (flagBelonging[position[i]] == 0) {
                    maxGroup++;
                    flagBelonging[position[i]] = maxGroup;
                }
            }

            IBond bondA = newBondList.get(i);
            for (int ato = 0; ato < 2; ato++) {
                IAtom atomA1 = bondA.getAtom(ato);
                List<IBond> bondA1s = molecule.getConnectedBondsList(atomA1);
                for (int j = 0; j < bondA1s.size(); j++) {
                    IBond bondB = bondA1s.get(j);
                    if (!newBondList.contains(bondB)) for (int k = 0; k < bondList.size(); k++)
                        if (bondList.get(k).equals(bondB)) if (flagBelonging[k] == 0) {
                            flagBelonging[k] = maxGroup;
                            pos++;
                            newBondList.add(bondB);
                            position[pos] = k;

                        }
                }
            }
            //if it is final size and not all are added
            if (newBondList.size() - 1 == i) for (int k = 0; k < bondList.size(); k++)
                if (!newBondList.contains(bondList.get(k))) {
                    newBondList.add(bondList.get(k));
                    position[i + 1] = k;
                    break;
                }
        }
        /* creating containers according groups */
        for (int i = 0; i < maxGroup; i++) {
            IAtomContainer container = molecule.getBuilder().newInstance(IAtomContainer.class);
            for (int j = 0; j < bondList.size(); j++) {
                if (flagBelonging[j] != i + 1) continue;
                IBond bond = bondList.get(j);
                IAtom atomA1 = bond.getBegin();
                IAtom atomA2 = bond.getEnd();
                if (!container.contains(atomA1)) container.addAtom(atomA1);
                if (!container.contains(atomA2)) container.addAtom(atomA2);
                container.addBond(bond);
            }
            setOfCont.addAtomContainer(container);
        }
        return setOfCont;
    }

    public  StructureResonanceGenerator();
    public  StructureResonanceGenerator(boolean lookingSymmetry);

}