import java.util.ArrayList;

import java.util.Objects;

    private final Map<Location, Archive> map = new HashMap<>();

        // build a map from Location to Archive

        for (Archive archive: archives) {

            for (Location l: archive.getClasses()) {

                if (!map.containsKey(l)) {

                    map.put(l, archive);

                } else {

                    // duplicated class warning?

                }

            }

        }

        // traverse and analyze all dependencies

            archive.visitDependences(deps);

        void visitArchiveDependence(Archive origin, Archive target, Profile profile);

        void visitDependence(String origin, Archive source, String target, Archive archive, Profile profile);

        for (ArchiveDeps.Dep d: r.requireArchives()) {

            v.visitArchiveDependence(r.archive, d.archive, d.profile);

        for (Map.Entry<String, SortedSet<ArchiveDeps.Dep>> e: r.deps.entrySet()) {

            String origin = e.getKey();

            for (ArchiveDeps.Dep d: e.getValue()) {

                if (type == Type.VERBOSE || d.archive != source) {

                    v.visitDependence(origin, source, d.target, d.archive, d.profile);

    /**

     * ArchiveDeps contains the dependencies for an Archive that

     * can have one or more classes.

     */

        final SortedMap<String, SortedSet<Dep>> deps;

        void add(String origin, String target, Archive targetArchive, String pkgName) {

            SortedSet<Dep> set = deps.get(origin);

            Profile p = targetArchive instanceof JDKArchive

                            ? Profile.getProfile(pkgName) : null;

            set.add(new Dep(target, targetArchive, p));

        }

        /**

         * Returns the list of Archive dependences.  The returned

         * list contains one {@code Dep} instance per one archive

         * and with the minimum profile this archive depends on.

         */

        List<Dep> requireArchives() {

            Map<Archive,Profile> map = new HashMap<>();

            for (Set<Dep> set: deps.values()) {

                for (Dep d: set) {

                    if (this.archive != d.archive) {

                        Profile p = map.get(d.archive);

                        if (p == null || (d.profile != null && p.profile < d.profile.profile)) {

                            map.put(d.archive, d.profile);

                        }

                    }

            List<Dep> list = new ArrayList<>();

            for (Map.Entry<Archive,Profile> e: map.entrySet()) {

                list.add(new Dep("", e.getKey(), e.getValue()));

            }

            return list;

        }

        /**

         * Dep represents a dependence where the target can be

         * a classname or packagename and the archive and profile

         * the target belongs to.

         */

        class Dep implements Comparable<Dep> {

            final String target;

            final Archive archive;

            final Profile profile;

            Dep(String target, Archive archive, Profile p) {

                this.target = target;

                this.archive = archive;

                this.profile = p;

            }

            @Override

            public boolean equals(Object o) {

                if (o instanceof Dep) {

                    Dep d = (Dep)o;

                    return this.archive == d.archive && this.target.equals(d.target);

                }

                return false;

            }

            @Override

            public int hashCode() {

                int hash = 3;

                hash = 17 * hash + Objects.hashCode(this.archive);

                hash = 17 * hash + Objects.hashCode(this.target);

                return hash;

            }

            @Override

            public int compareTo(Dep o) {

                if (this.target.equals(o.target)) {

                    if (this.archive == o.archive) {

                        return 0;

                    } else {

                        return this.archive.getFileName().compareTo(o.archive.getFileName());

                    }

                }

                return this.target.compareTo(o.target);

            }

        @Override

            Archive targetArchive =

                this.archive.getClasses().contains(t) ? this.archive : map.get(t);

            if (targetArchive == null) {

                map.put(t, targetArchive = NOT_FOUND);

            }

            String origin = o.getClassName();

            String target = t.getClassName();

            add(origin, target, targetArchive, t.getPackageName());

        @Override

            Archive targetArchive =

                this.archive.getClasses().contains(t) ? this.archive : map.get(t);

            if (targetArchive == null) {

                map.put(t, targetArchive = NOT_FOUND);

            }

            String origin = packageOf(o);

            String target = packageOf(t);

            add(origin, target, targetArchive, t.getPackageName());

        public String packageOf(Location o) {

            String pkg = o.getPackageName();