/*!
 *  GMAP3 Plugin for JQuery
 *  Version   : 5.1.1
 *  Date      : 2013-05-25
 *  Licence   : GPL v3 : http://www.gnu.org/licenses/gpl.html
 *  Author    : DEMONTE Jean-Baptiste
 *  Contact   : jbdemonte@gmail.com
 *  Web site  : http://gmap3.net
 */
(function(y, t) {
    var z, i = 0;

    function J() {
        if (!z) {
            z = {
                verbose: false,
                queryLimit: {
                    attempt: 5,
                    delay: 250,
                    random: 250
                },
                classes: {
                    Map: google.maps.Map,
                    Marker: google.maps.Marker,
                    InfoWindow: google.maps.InfoWindow,
                    Circle: google.maps.Circle,
                    Rectangle: google.maps.Rectangle,
                    OverlayView: google.maps.OverlayView,
                    StreetViewPanorama: google.maps.StreetViewPanorama,
                    KmlLayer: google.maps.KmlLayer,
                    TrafficLayer: google.maps.TrafficLayer,
                    BicyclingLayer: google.maps.BicyclingLayer,
                    GroundOverlay: google.maps.GroundOverlay,
                    StyledMapType: google.maps.StyledMapType,
                    ImageMapType: google.maps.ImageMapType
                },
                map: {
                    mapTypeId: google.maps.MapTypeId.ROADMAP,
                    center: [46.578498, 2.457275],
                    zoom: 2
                },
                overlay: {
                    pane: "floatPane",
                    content: "",
                    offset: {
                        x: 0,
                        y: 0
                    }
                },
                geoloc: {
                    getCurrentPosition: {
                        maximumAge: 60000,
                        timeout: 5000
                    }
                }
            }
        }
    }

    function k(M, L) {
        return M !== t ? M : "gmap3_" + (L ? i + 1 : ++i)
    }

    function d(L) {
        var O = function(P) {
                return parseInt(P, 10)
            },
            N = google.maps.version.split(".").map(O),
            M;
        L = L.split(".").map(O);
        for (M = 0; M < L.length; M++) {
            if (N.hasOwnProperty(M)) {
                if (N[M] < L[M]) {
                    return false
                }
            } else {
                return false
            }
        }
        return true
    }

    function n(P, L, N, Q, O) {
        if (L.todo.events || L.todo.onces) {
            var M = {
                id: Q,
                data: L.todo.data,
                tag: L.todo.tag
            };
            if (L.todo.events) {
                y.each(L.todo.events, function(R, U) {
                    var T = P,
                        S = U;
                    if (y.isArray(U)) {
                        T = U[0];
                        S = U[1]
                    }
                    google.maps.event.addListener(N, R, function(V) {
                        S.apply(T, [O ? O : N, V, M])
                    })
                })
            }
            if (L.todo.onces) {
                y.each(L.todo.onces, function(R, U) {
                    var T = P,
                        S = U;
                    if (y.isArray(U)) {
                        T = U[0];
                        S = U[1]
                    }
                    google.maps.event.addListenerOnce(N, R, function(V) {
                        S.apply(T, [O ? O : N, V, M])
                    })
                })
            }
        }
    }

    function l() {
        var L = [];
        this.empty = function() {
            return !L.length
        };
        this.add = function(M) {
            L.push(M)
        };
        this.get = function() {
            return L.length ? L[0] : false
        };
        this.ack = function() {
            L.shift()
        }
    }

    function w(T, L, N) {
        var R = {},
            P = this,
            Q, S = {
                latLng: {
                    map: false,
                    marker: false,
                    infowindow: false,
                    circle: false,
                    overlay: false,
                    getlatlng: false,
                    getmaxzoom: false,
                    getelevation: false,
                    streetviewpanorama: false,
                    getaddress: true
                },
                geoloc: {
                    getgeoloc: true
                }
            };
        if (typeof N === "string") {
            N = M(N)
        }

        function M(V) {
            var U = {};
            U[V] = {};
            return U
        }

        function O() {
            var U;
            for (U in N) {
                if (U in R) {
                    continue
                }
                return U
            }
        }
        this.run = function() {
            var U, V;
            while (U = O()) {
                if (typeof T[U] === "function") {
                    Q = U;
                    V = y.extend(true, {}, z[U] || {}, N[U].options || {});
                    if (U in S.latLng) {
                        if (N[U].values) {
                            x(N[U].values, T, T[U], {
                                todo: N[U],
                                opts: V,
                                session: R
                            })
                        } else {
                            v(T, T[U], S.latLng[U], {
                                todo: N[U],
                                opts: V,
                                session: R
                            })
                        }
                    } else {
                        if (U in S.geoloc) {
                            o(T, T[U], {
                                todo: N[U],
                                opts: V,
                                session: R
                            })
                        } else {
                            T[U].apply(T, [{
                                todo: N[U],
                                opts: V,
                                session: R
                            }])
                        }
                    }
                    return
                } else {
                    R[U] = null
                }
            }
            L.apply(T, [N, R])
        };
        this.ack = function(U) {
            R[Q] = U;
            P.run.apply(P, [])
        }
    }

    function c(N) {
        var L, M = [];
        for (L in N) {
            M.push(L)
        }
        return M
    }

    function b(N, Q) {
        var L = {};
        if (N.todo) {
            for (var M in N.todo) {
                if ((M !== "options") && (M !== "values")) {
                    L[M] = N.todo[M]
                }
            }
        }
        var O, P = ["data", "tag", "id", "events", "onces"];
        for (O = 0; O < P.length; O++) {
            A(L, P[O], Q, N.todo)
        }
        L.options = y.extend({}, N.opts || {}, Q.options || {});
        return L
    }

    function A(N, M) {
        for (var L = 2; L < arguments.length; L++) {
            if (M in arguments[L]) {
                N[M] = arguments[L][M];
                return
            }
        }
    }

    function r() {
        var L = [];
        this.get = function(S) {
            if (L.length) {
                var P, O, N, R, M, Q = c(S);
                for (P = 0; P < L.length; P++) {
                    R = L[P];
                    M = Q.length == R.keys.length;
                    for (O = 0;
                         (O < Q.length) && M; O++) {
                        N = Q[O];
                        M = N in R.request;
                        if (M) {
                            if ((typeof S[N] === "object") && ("equals" in S[N]) && (typeof S[N] === "function")) {
                                M = S[N].equals(R.request[N])
                            } else {
                                M = S[N] === R.request[N]
                            }
                        }
                    }
                    if (M) {
                        return R.results
                    }
                }
            }
        };
        this.store = function(N, M) {
            L.push({
                request: N,
                keys: c(N),
                results: M
            })
        }
    }

    function e(Q, P, O, L) {
        var N = this,
            M = [];
        z.classes.OverlayView.call(this);
        this.setMap(Q);
        this.onAdd = function() {
            var R = this.getPanes();
            if (P.pane in R) {
                y(R[P.pane]).append(L)
            }
            y.each("dblclick click mouseover mousemove mouseout mouseup mousedown".split(" "), function(T, S) {
                M.push(google.maps.event.addDomListener(L[0], S, function(U) {
                    y.Event(U).stopPropagation();
                    google.maps.event.trigger(N, S, [U]);
                    N.draw()
                }))
            });
            M.push(google.maps.event.addDomListener(L[0], "contextmenu", function(S) {
                y.Event(S).stopPropagation();
                google.maps.event.trigger(N, "rightclick", [S]);
                N.draw()
            }))
        };
        this.getPosition = function() {
            return O
        };
        this.draw = function() {
            var R = this.getProjection().fromLatLngToDivPixel(O);
            L.css("left", (R.x + P.offset.x) + "px").css("top", (R.y + P.offset.y) + "px")
        };
        this.onRemove = function() {
            for (var R = 0; R < M.length; R++) {
                google.maps.event.removeListener(M[R])
            }
            L.remove()
        };
        this.hide = function() {
            L.hide()
        };
        this.show = function() {
            L.show()
        };
        this.toggle = function() {
            if (L) {
                if (L.is(":visible")) {
                    this.show()
                } else {
                    this.hide()
                }
            }
        };
        this.toggleDOM = function() {
            if (this.getMap()) {
                this.setMap(null)
            } else {
                this.setMap(Q)
            }
        };
        this.getDOMElement = function() {
            return L[0]
        }
    }

    function f(O, L) {
        function M() {
            this.onAdd = function() {};
            this.onRemove = function() {};
            this.draw = function() {};
            return z.classes.OverlayView.apply(this, [])
        }
        M.prototype = z.classes.OverlayView.prototype;
        var N = new M();
        N.setMap(O);
        return N
    }

    function F(ae, ao, aa) {
        var an = false,
            ai = false,
            af = false,
            Z = false,
            W = true,
            V = this,
            N = [],
            T = {},
            ad = {},
            U = {},
            aj = [],
            ah = [],
            O = [],
            ak = f(ao, aa.radius),
            Y, ap, am, P, Q;
        S();

        function L(aq) {
            if (!aj[aq]) {
                delete ah[aq].options.map;
                aj[aq] = new z.classes.Marker(ah[aq].options);
                n(ae, {
                    todo: ah[aq]
                }, aj[aq], ah[aq].id)
            }
        }
        this.getById = function(aq) {
            if (aq in ad) {
                L(ad[aq]);
                return aj[ad[aq]]
            }
            return false
        };
        this.rm = function(ar) {
            var aq = ad[ar];
            if (aj[aq]) {
                aj[aq].setMap(null)
            }
            delete aj[aq];
            aj[aq] = false;
            delete ah[aq];
            ah[aq] = false;
            delete O[aq];
            O[aq] = false;
            delete ad[ar];
            delete U[aq];
            ai = true
        };
        this.clearById = function(aq) {
            if (aq in ad) {
                this.rm(aq);
                return true
            }
        };
        this.clear = function(az, av, aA) {
            var ar, ay, at, aw, au, ax = [],
                aq = C(aA);
            if (az) {
                ar = ah.length - 1;
                ay = -1;
                at = -1
            } else {
                ar = 0;
                ay = ah.length;
                at = 1
            }
            for (aw = ar; aw != ay; aw += at) {
                if (ah[aw]) {
                    if (!aq || aq(ah[aw].tag)) {
                        ax.push(U[aw]);
                        if (av || az) {
                            break
                        }
                    }
                }
            }
            for (au = 0; au < ax.length; au++) {
                this.rm(ax[au])
            }
        };
        this.add = function(aq, ar) {
            aq.id = k(aq.id);
            this.clearById(aq.id);
            ad[aq.id] = aj.length;
            U[aj.length] = aq.id;
            aj.push(null);
            ah.push(aq);
            O.push(ar);
            ai = true
        };
        this.addMarker = function(ar, aq) {
            aq = aq || {};
            aq.id = k(aq.id);
            this.clearById(aq.id);
            if (!aq.options) {
                aq.options = {}
            }
            aq.options.position = ar.getPosition();
            n(ae, {
                todo: aq
            }, ar, aq.id);
            ad[aq.id] = aj.length;
            U[aj.length] = aq.id;
            aj.push(ar);
            ah.push(aq);
            O.push(aq.data || {});
            ai = true
        };
        this.todo = function(aq) {
            return ah[aq]
        };
        this.value = function(aq) {
            return O[aq]
        };
        this.marker = function(aq) {
            if (aq in aj) {
                L(aq);
                return aj[aq]
            }
            return false
        };
        this.markerIsSet = function(aq) {
            return Boolean(aj[aq])
        };
        this.setMarker = function(ar, aq) {
            aj[ar] = aq
        };
        this.store = function(aq, ar, at) {
            T[aq.ref] = {
                obj: ar,
                shadow: at
            }
        };
        this.free = function() {
            for (var aq = 0; aq < N.length; aq++) {
                google.maps.event.removeListener(N[aq])
            }
            N = [];
            y.each(T, function(ar) {
                ac(ar)
            });
            T = {};
            y.each(ah, function(ar) {
                ah[ar] = null
            });
            ah = [];
            y.each(aj, function(ar) {
                if (aj[ar]) {
                    aj[ar].setMap(null);
                    delete aj[ar]
                }
            });
            aj = [];
            y.each(O, function(ar) {
                delete O[ar]
            });
            O = [];
            ad = {};
            U = {}
        };
        this.filter = function(aq) {
            am = aq;
            ag()
        };
        this.enable = function(aq) {
            if (W != aq) {
                W = aq;
                ag()
            }
        };
        this.display = function(aq) {
            P = aq
        };
        this.error = function(aq) {
            Q = aq
        };
        this.beginUpdate = function() {
            an = true
        };
        this.endUpdate = function() {
            an = false;
            if (ai) {
                ag()
            }
        };
        this.autofit = function(ar) {
            for (var aq = 0; aq < ah.length; aq++) {
                if (ah[aq]) {
                    ar.extend(ah[aq].options.position)
                }
            }
        };

        function S() {
            ap = ak.getProjection();
            if (!ap) {
                setTimeout(function() {
                    S.apply(V, [])
                }, 25);
                return
            }
            Z = true;
            N.push(google.maps.event.addListener(ao, "zoom_changed", function() {
                al()
            }));
            N.push(google.maps.event.addListener(ao, "bounds_changed", function() {
                al()
            }));
            ag()
        }

        function ac(aq) {
            if (typeof T[aq] === "object") {
                if (typeof(T[aq].obj.setMap) === "function") {
                    T[aq].obj.setMap(null)
                }
                if (typeof(T[aq].obj.remove) === "function") {
                    T[aq].obj.remove()
                }
                if (typeof(T[aq].shadow.remove) === "function") {
                    T[aq].obj.remove()
                }
                if (typeof(T[aq].shadow.setMap) === "function") {
                    T[aq].shadow.setMap(null)
                }
                delete T[aq].obj;
                delete T[aq].shadow
            } else {
                if (aj[aq]) {
                    aj[aq].setMap(null)
                }
            }
            delete T[aq]
        }

        function M() {
            var ay, ax, aw, au, av, at, ar, aq;
            if (arguments[0] instanceof google.maps.LatLng) {
                ay = arguments[0].lat();
                aw = arguments[0].lng();
                if (arguments[1] instanceof google.maps.LatLng) {
                    ax = arguments[1].lat();
                    au = arguments[1].lng()
                } else {
                    ax = arguments[1];
                    au = arguments[2]
                }
            } else {
                ay = arguments[0];
                aw = arguments[1];
                if (arguments[2] instanceof google.maps.LatLng) {
                    ax = arguments[2].lat();
                    au = arguments[2].lng()
                } else {
                    ax = arguments[2];
                    au = arguments[3]
                }
            }
            av = Math.PI * ay / 180;
            at = Math.PI * aw / 180;
            ar = Math.PI * ax / 180;
            aq = Math.PI * au / 180;
            return 1000 * 6371 * Math.acos(Math.min(Math.cos(av) * Math.cos(ar) * Math.cos(at) * Math.cos(aq) + Math.cos(av) * Math.sin(at) * Math.cos(ar) * Math.sin(aq) + Math.sin(av) * Math.sin(ar), 1))
        }

        function R() {
            var aq = M(ao.getCenter(), ao.getBounds().getNorthEast()),
                ar = new google.maps.Circle({
                    center: ao.getCenter(),
                    radius: 1.25 * aq
                });
            return ar.getBounds()
        }

        function X() {
            var ar = {},
                aq;
            for (aq in T) {
                ar[aq] = true
            }
            return ar
        }

        function al() {
            clearTimeout(Y);
            Y = setTimeout(function() {
                ag()
            }, 25)
        }

        function ab(ar) {
            var au = ap.fromLatLngToDivPixel(ar),
                at = ap.fromDivPixelToLatLng(new google.maps.Point(au.x + aa.radius, au.y - aa.radius)),
                aq = ap.fromDivPixelToLatLng(new google.maps.Point(au.x - aa.radius, au.y + aa.radius));
            return new google.maps.LatLngBounds(aq, at)
        }

        function ag() {
            if (an || af || !Z) {
                return
            }
            var aE = [],
                aG = {},
                aF = ao.getZoom(),
                aH = ("maxZoom" in aa) && (aF > aa.maxZoom),
                aw = X(),
                av, au, at, aA, ar = false,
                aq, aD, ay, az, aB, aC, ax;
            ai = false;
            if (aF > 3) {
                aq = R();
                ar = aq.getSouthWest().lng() < aq.getNorthEast().lng()
            }
            for (av = 0; av < ah.length; av++) {
                if (ah[av] && (!ar || aq.contains(ah[av].options.position)) && (!am || am(O[av]))) {
                    aE.push(av)
                }
            }
            while (1) {
                av = 0;
                while (aG[av] && (av < aE.length)) {
                    av++
                }
                if (av == aE.length) {
                    break
                }
                aA = [];
                if (W && !aH) {
                    ax = 10;
                    do {
                        az = aA;
                        aA = [];
                        ax--;
                        if (az.length) {
                            ay = aq.getCenter()
                        } else {
                            ay = ah[aE[av]].options.position
                        }
                        aq = ab(ay);
                        for (au = av; au < aE.length; au++) {
                            if (aG[au]) {
                                continue
                            }
                            if (aq.contains(ah[aE[au]].options.position)) {
                                aA.push(au)
                            }
                        }
                    } while ((az.length < aA.length) && (aA.length > 1) && ax)
                } else {
                    for (au = av; au < aE.length; au++) {
                        if (aG[au]) {
                            continue
                        }
                        aA.push(au);
                        break
                    }
                }
                aD = {
                    indexes: [],
                    ref: []
                };
                aB = aC = 0;
                for (at = 0; at < aA.length; at++) {
                    aG[aA[at]] = true;
                    aD.indexes.push(aE[aA[at]]);
                    aD.ref.push(aE[aA[at]]);
                    aB += ah[aE[aA[at]]].options.position.lat();
                    aC += ah[aE[aA[at]]].options.position.lng()
                }
                aB /= aA.length;
                aC /= aA.length;
                aD.latLng = new google.maps.LatLng(aB, aC);
                aD.ref = aD.ref.join("-");
                if (aD.ref in aw) {
                    delete aw[aD.ref]
                } else {
                    if (aA.length === 1) {
                        T[aD.ref] = true
                    }
                    P(aD)
                }
            }
            y.each(aw, function(aI) {
                ac(aI)
            });
            af = false
        }
    }

    function a(M, L) {
        this.id = function() {
            return M
        };
        this.filter = function(N) {
            L.filter(N)
        };
        this.enable = function() {
            L.enable(true)
        };
        this.disable = function() {
            L.enable(false)
        };
        this.add = function(O, N, P) {
            if (!P) {
                L.beginUpdate()
            }
            L.addMarker(O, N);
            if (!P) {
                L.endUpdate()
            }
        };
        this.getById = function(N) {
            return L.getById(N)
        };
        this.clearById = function(P, O) {
            var N;
            if (!O) {
                L.beginUpdate()
            }
            N = L.clearById(P);
            if (!O) {
                L.endUpdate()
            }
            return N
        };
        this.clear = function(P, Q, N, O) {
            if (!O) {
                L.beginUpdate()
            }
            L.clear(P, Q, N);
            if (!O) {
                L.endUpdate()
            }
        }
    }

    function D() {
        var M = {},
            N = {};

        function L(P) {
            return {
                id: P.id,
                name: P.name,
                object: P.obj,
                tag: P.tag,
                data: P.data
            }
        }
        this.add = function(R, Q, T, S) {
            var P = R.todo || {},
                U = k(P.id);
            if (!M[Q]) {
                M[Q] = []
            }
            if (U in N) {
                this.clearById(U)
            }
            N[U] = {
                obj: T,
                sub: S,
                name: Q,
                id: U,
                tag: P.tag,
                data: P.data
            };
            M[Q].push(U);
            return U
        };
        this.getById = function(R, Q, P) {
            if (R in N) {
                if (Q) {
                    return N[R].sub
                } else {
                    if (P) {
                        return L(N[R])
                    }
                }
                return N[R].obj
            }
            return false
        };
        this.get = function(R, T, P, S) {
            var V, U, Q = C(P);
            if (!M[R] || !M[R].length) {
                return null
            }
            V = M[R].length;
            while (V) {
                V--;
                U = M[R][T ? V : M[R].length - V - 1];
                if (U && N[U]) {
                    if (Q && !Q(N[U].tag)) {
                        continue
                    }
                    return S ? L(N[U]) : N[U].obj
                }
            }
            return null
        };
        this.all = function(S, Q, T) {
            var P = [],
                R = C(Q),
                U = function(X) {
                    var V, W;
                    for (V = 0; V < M[X].length; V++) {
                        W = M[X][V];
                        if (W && N[W]) {
                            if (R && !R(N[W].tag)) {
                                continue
                            }
                            P.push(T ? L(N[W]) : N[W].obj)
                        }
                    }
                };
            if (S in M) {
                U(S)
            } else {
                if (S === t) {
                    for (S in M) {
                        U(S)
                    }
                }
            }
            return P
        };

        function O(P) {
            if (typeof(P.setMap) === "function") {
                P.setMap(null)
            }
            if (typeof(P.remove) === "function") {
                P.remove()
            }
            if (typeof(P.free) === "function") {
                P.free()
            }
            P = null
        }
        this.rm = function(S, Q, R) {
            var P, T;
            if (!M[S]) {
                return false
            }
            if (Q) {
                if (R) {
                    for (P = M[S].length - 1; P >= 0; P--) {
                        T = M[S][P];
                        if (Q(N[T].tag)) {
                            break
                        }
                    }
                } else {
                    for (P = 0; P < M[S].length; P++) {
                        T = M[S][P];
                        if (Q(N[T].tag)) {
                            break
                        }
                    }
                }
            } else {
                P = R ? M[S].length - 1 : 0
            }
            if (!(P in M[S])) {
                return false
            }
            return this.clearById(M[S][P], P)
        };
        this.clearById = function(S, P) {
            if (S in N) {
                var R, Q = N[S].name;
                for (R = 0; P === t && R < M[Q].length; R++) {
                    if (S === M[Q][R]) {
                        P = R
                    }
                }
                O(N[S].obj);
                if (N[S].sub) {
                    O(N[S].sub)
                }
                delete N[S];
                M[Q].splice(P, 1);
                return true
            }
            return false
        };
        this.objGetById = function(R) {
            var Q;
            if (M.clusterer) {
                for (var P in M.clusterer) {
                    if ((Q = N[M.clusterer[P]].obj.getById(R)) !== false) {
                        return Q
                    }
                }
            }
            return false
        };
        this.objClearById = function(Q) {
            if (M.clusterer) {
                for (var P in M.clusterer) {
                    if (N[M.clusterer[P]].obj.clearById(Q)) {
                        return true
                    }
                }
            }
            return null
        };
        this.clear = function(V, U, W, P) {
            var R, T, S, Q = C(P);
            if (!V || !V.length) {
                V = [];
                for (R in M) {
                    V.push(R)
                }
            } else {
                V = g(V)
            }
            for (T = 0; T < V.length; T++) {
                S = V[T];
                if (U) {
                    this.rm(S, Q, true)
                } else {
                    if (W) {
                        this.rm(S, Q, false)
                    } else {
                        while (this.rm(S, Q, false)) {}
                    }
                }
            }
        };
        this.objClear = function(S, R, T, Q) {
            if (M.clusterer && (y.inArray("marker", S) >= 0 || !S.length)) {
                for (var P in M.clusterer) {
                    N[M.clusterer[P]].obj.clear(R, T, Q)
                }
            }
        }
    }
    var m = {},
        H = new r();

    function p() {
        if (!m.geocoder) {
            m.geocoder = new google.maps.Geocoder()
        }
        return m.geocoder
    }

    function G() {
        if (!m.directionsService) {
            m.directionsService = new google.maps.DirectionsService()
        }
        return m.directionsService
    }

    function h() {
        if (!m.elevationService) {
            m.elevationService = new google.maps.ElevationService()
        }
        return m.elevationService
    }

    function q() {
        if (!m.maxZoomService) {
            m.maxZoomService = new google.maps.MaxZoomService()
        }
        return m.maxZoomService
    }

    function B() {
        if (!m.distanceMatrixService) {
            m.distanceMatrixService = new google.maps.DistanceMatrixService()
        }
        return m.distanceMatrixService
    }

    function u() {
        if (z.verbose) {
            var L, M = [];
            if (window.console && (typeof console.error === "function")) {
                for (L = 0; L < arguments.length; L++) {
                    M.push(arguments[L])
                }
                console.error.apply(console, M)
            } else {
                M = "";
                for (L = 0; L < arguments.length; L++) {
                    M += arguments[L].toString() + " "
                }
                alert(M)
            }
        }
    }

    function E(L) {
        return (typeof(L) === "number" || typeof(L) === "string") && L !== "" && !isNaN(L)
    }

    function g(N) {
        var M, L = [];
        if (N !== t) {
            if (typeof(N) === "object") {
                if (typeof(N.length) === "number") {
                    L = N
                } else {
                    for (M in N) {
                        L.push(N[M])
                    }
                }
            } else {
                L.push(N)
            }
        }
        return L
    }

    function C(L) {
        if (L) {
            if (typeof L === "function") {
                return L
            }
            L = g(L);
            return function(N) {
                if (N === t) {
                    return false
                }
                if (typeof N === "object") {
                    for (var M = 0; M < N.length; M++) {
                        if (y.inArray(N[M], L) >= 0) {
                            return true
                        }
                    }
                    return false
                }
                return y.inArray(N, L) >= 0
            }
        }
    }

    function I(M, O, L) {
        var N = O ? M : null;
        if (!M || (typeof M === "string")) {
            return N
        }
        if (M.latLng) {
            return I(M.latLng)
        }
        if (M instanceof google.maps.LatLng) {
            return M
        } else {
            if (E(M.lat)) {
                return new google.maps.LatLng(M.lat, M.lng)
            } else {
                if (!L && y.isArray(M)) {
                    if (!E(M[0]) || !E(M[1])) {
                        return N
                    }
                    return new google.maps.LatLng(M[0], M[1])
                }
            }
        }
        return N
    }

    function j(M) {
        var N, L;
        if (!M || M instanceof google.maps.LatLngBounds) {
            return M || null
        }
        if (y.isArray(M)) {
            if (M.length == 2) {
                N = I(M[0]);
                L = I(M[1])
            } else {
                if (M.length == 4) {
                    N = I([M[0], M[1]]);
                    L = I([M[2], M[3]])
                }
            }
        } else {
            if (("ne" in M) && ("sw" in M)) {
                N = I(M.ne);
                L = I(M.sw)
            } else {
                if (("n" in M) && ("e" in M) && ("s" in M) && ("w" in M)) {
                    N = I([M.n, M.e]);
                    L = I([M.s, M.w])
                }
            }
        }
        if (N && L) {
            return new google.maps.LatLngBounds(L, N)
        }
        return null
    }

    function v(T, L, O, S, P) {
        var N = O ? I(S.todo, false, true) : false,
            R = N ? {
                latLng: N
            } : (S.todo.address ? (typeof(S.todo.address) === "string" ? {
                address: S.todo.address
            } : S.todo.address) : false),
            M = R ? H.get(R) : false,
            Q = this;
        if (R) {
            P = P || 0;
            if (M) {
                S.latLng = M.results[0].geometry.location;
                S.results = M.results;
                S.status = M.status;
                L.apply(T, [S])
            } else {
                if (R.location) {
                    R.location = I(R.location)
                }
                if (R.bounds) {
                    R.bounds = j(R.bounds)
                }
                p().geocode(R, function(V, U) {
                    if (U === google.maps.GeocoderStatus.OK) {
                        H.store(R, {
                            results: V,
                            status: U
                        });
                        S.latLng = V[0].geometry.location;
                        S.results = V;
                        S.status = U;
                        L.apply(T, [S])
                    } else {
                        if ((U === google.maps.GeocoderStatus.OVER_QUERY_LIMIT) && (P < z.queryLimit.attempt)) {
                            setTimeout(function() {
                                v.apply(Q, [T, L, O, S, P + 1])
                            }, z.queryLimit.delay + Math.floor(Math.random() * z.queryLimit.random))
                        } else {
                            u("geocode failed", U, R);
                            S.latLng = S.results = false;
                            S.status = U;
                            L.apply(T, [S])
                        }
                    }
                })
            }
        } else {
            S.latLng = I(S.todo, false, true);
            L.apply(T, [S])
        }
    }

    function x(Q, L, R, M) {
        var O = this,
            N = -1;

        function P() {
            do {
                N++
            } while ((N < Q.length) && !("address" in Q[N]));
            if (N >= Q.length) {
                R.apply(L, [M]);
                return
            }
            v(O, function(S) {
                delete S.todo;
                y.extend(Q[N], S);
                P.apply(O, [])
            }, true, {
                todo: Q[N]
            })
        }
        P()
    }

    function o(L, O, M) {
        var N = false;
        if (navigator && navigator.geolocation) {
            navigator.geolocation.getCurrentPosition(function(P) {
                if (N) {
                    return
                }
                N = true;
                M.latLng = new google.maps.LatLng(P.coords.latitude, P.coords.longitude);
                O.apply(L, [M])
            }, function() {
                if (N) {
                    return
                }
                N = true;
                M.latLng = false;
                O.apply(L, [M])
            }, M.opts.getCurrentPosition)
        } else {
            M.latLng = false;
            O.apply(L, [M])
        }
    }

    function K(T) {
        var S = this,
            U = new l(),
            V = new D(),
            N = null,
            P;
        this._plan = function(Z) {
            for (var Y = 0; Y < Z.length; Y++) {
                U.add(new w(S, R, Z[Y]))
            }
            Q()
        };

        function Q() {
            if (!P && (P = U.get())) {
                P.run()
            }
        }

        function R() {
            P = null;
            U.ack();
            Q.call(S)
        }

        function X(Y) {
            if (Y.todo.callback) {
                var Z = Array.prototype.slice.call(arguments, 1);
                if (typeof Y.todo.callback === "function") {
                    Y.todo.callback.apply(T, Z)
                } else {
                    if (y.isArray(Y.todo.callback)) {
                        if (typeof Y.todo.callback[1] === "function") {
                            Y.todo.callback[1].apply(Y.todo.callback[0], Z)
                        }
                    }
                }
            }
        }

        function O(Y, Z, aa) {
            if (aa) {
                n(T, Y, Z, aa)
            }
            X(Y, Z);
            P.ack(Z)
        }

        function L(aa, Y) {
            Y = Y || {};
            if (N) {
                if (Y.todo && Y.todo.options) {
                    if (Y.todo.options.center) {
                        Y.todo.options.center = I(Y.todo.options.center)
                    }
                    N.setOptions(Y.todo.options)
                }
            } else {
                var Z = Y.opts || y.extend(true, {}, z.map, Y.todo && Y.todo.options ? Y.todo.options : {});
                Z.center = aa || I(Z.center);
                N = new z.classes.Map(T.get(0), Z)
            }
        }
        this.map = function(Y) {
            L(Y.latLng, Y);
            n(T, Y, N);
            O(Y, N)
        };
        this.destroy = function(Y) {
            V.clear();
            T.empty();
            if (N) {
                N = null
            }
            O(Y, true)
        };
        this.infowindow = function(Z) {
            var aa = [],
                Y = "values" in Z.todo;
            if (!Y) {
                if (Z.latLng) {
                    Z.opts.position = Z.latLng
                }
                Z.todo.values = [{
                    options: Z.opts
                }]
            }
            y.each(Z.todo.values, function(ac, ad) {
                var af, ae, ab = b(Z, ad);
                ab.options.position = ab.options.position ? I(ab.options.position) : I(ad.latLng);
                if (!N) {
                    L(ab.options.position)
                }
                ae = new z.classes.InfoWindow(ab.options);
                if (ae && ((ab.open === t) || ab.open)) {
                    if (Y) {
                        ae.open(N, ab.anchor ? ab.anchor : t)
                    } else {
                        ae.open(N, ab.anchor ? ab.anchor : (Z.latLng ? t : (Z.session.marker ? Z.session.marker : t)))
                    }
                }
                aa.push(ae);
                af = V.add({
                    todo: ab
                }, "infowindow", ae);
                n(T, {
                    todo: ab
                }, ae, af)
            });
            O(Z, Y ? aa : aa[0])
        };
        this.circle = function(Z) {
            var aa = [],
                Y = "values" in Z.todo;
            if (!Y) {
                Z.opts.center = Z.latLng || I(Z.opts.center);
                Z.todo.values = [{
                    options: Z.opts
                }]
            }
            if (!Z.todo.values.length) {
                O(Z, false);
                return
            }
            y.each(Z.todo.values, function(ac, ad) {
                var af, ae, ab = b(Z, ad);
                ab.options.center = ab.options.center ? I(ab.options.center) : I(ad);
                if (!N) {
                    L(ab.options.center)
                }
                ab.options.map = N;
                ae = new z.classes.Circle(ab.options);
                aa.push(ae);
                af = V.add({
                    todo: ab
                }, "circle", ae);
                n(T, {
                    todo: ab
                }, ae, af)
            });
            O(Z, Y ? aa : aa[0])
        };
        this.overlay = function(aa, Z) {
            var ab = [],
                Y = "values" in aa.todo;
            if (!Y) {
                aa.todo.values = [{
                    latLng: aa.latLng,
                    options: aa.opts
                }]
            }
            if (!aa.todo.values.length) {
                O(aa, false);
                return
            }
            if (!e.__initialised) {
                e.prototype = new z.classes.OverlayView();
                e.__initialised = true
            }
            y.each(aa.todo.values, function(ae, af) {
                var ah, ag, ac = b(aa, af),
                    ad = y(document.createElement("div")).css({
                        border: "none",
                        borderWidth: "0px",
                        position: "absolute"
                    });
                ad.append(ac.options.content);
                ag = new e(N, ac.options, I(ac) || I(af), ad);
                ab.push(ag);
                ad = null;
                if (!Z) {
                    ah = V.add(aa, "overlay", ag);
                    n(T, {
                        todo: ac
                    }, ag, ah)
                }
            });
            if (Z) {
                return ab[0]
            }
            O(aa, Y ? ab : ab[0])
        };
        this.getaddress = function(Y) {
            X(Y, Y.results, Y.status);
            P.ack()
        };
        this.getlatlng = function(Y) {
            X(Y, Y.results, Y.status);
            P.ack()
        };
        this.getmaxzoom = function(Y) {
            q().getMaxZoomAtLatLng(Y.latLng, function(Z) {
                X(Y, Z.status === google.maps.MaxZoomStatus.OK ? Z.zoom : false, status);
                P.ack()
            })
        };
        this.getelevation = function(Z) {
            var aa, Y = [],
                ab = function(ad, ac) {
                    X(Z, ac === google.maps.ElevationStatus.OK ? ad : false, ac);
                    P.ack()
                };
            if (Z.latLng) {
                Y.push(Z.latLng)
            } else {
                Y = g(Z.todo.locations || []);
                for (aa = 0; aa < Y.length; aa++) {
                    Y[aa] = I(Y[aa])
                }
            }
            if (Y.length) {
                h().getElevationForLocations({
                    locations: Y
                }, ab)
            } else {
                if (Z.todo.path && Z.todo.path.length) {
                    for (aa = 0; aa < Z.todo.path.length; aa++) {
                        Y.push(I(Z.todo.path[aa]))
                    }
                }
                if (Y.length) {
                    h().getElevationAlongPath({
                        path: Y,
                        samples: Z.todo.samples
                    }, ab)
                } else {
                    P.ack()
                }
            }
        };
        this.defaults = function(Y) {
            y.each(Y.todo, function(Z, aa) {
                if (typeof z[Z] === "object") {
                    z[Z] = y.extend({}, z[Z], aa)
                } else {
                    z[Z] = aa
                }
            });
            P.ack(true)
        };
        this.rectangle = function(Z) {
            var aa = [],
                Y = "values" in Z.todo;
            if (!Y) {
                Z.todo.values = [{
                    options: Z.opts
                }]
            }
            if (!Z.todo.values.length) {
                O(Z, false);
                return
            }
            y.each(Z.todo.values, function(ac, ad) {
                var af, ae, ab = b(Z, ad);
                ab.options.bounds = ab.options.bounds ? j(ab.options.bounds) : j(ad);
                if (!N) {
                    L(ab.options.bounds.getCenter())
                }
                ab.options.map = N;
                ae = new z.classes.Rectangle(ab.options);
                aa.push(ae);
                af = V.add({
                    todo: ab
                }, "rectangle", ae);
                n(T, {
                    todo: ab
                }, ae, af)
            });
            O(Z, Y ? aa : aa[0])
        };

        function M(Z, aa, ab) {
            var ac = [],
                Y = "values" in Z.todo;
            if (!Y) {
                Z.todo.values = [{
                    options: Z.opts
                }]
            }
            if (!Z.todo.values.length) {
                O(Z, false);
                return
            }
            L();
            y.each(Z.todo.values, function(af, ah) {
                var aj, ag, ae, ai, ad = b(Z, ah);
                if (ad.options[ab]) {
                    if (ad.options[ab][0][0] && y.isArray(ad.options[ab][0][0])) {
                        for (ag = 0; ag < ad.options[ab].length; ag++) {
                            for (ae = 0; ae < ad.options[ab][ag].length; ae++) {
                                ad.options[ab][ag][ae] = I(ad.options[ab][ag][ae])
                            }
                        }
                    } else {
                        for (ag = 0; ag < ad.options[ab].length; ag++) {
                            ad.options[ab][ag] = I(ad.options[ab][ag])
                        }
                    }
                }
                ad.options.map = N;
                ai = new google.maps[aa](ad.options);
                ac.push(ai);
                aj = V.add({
                    todo: ad
                }, aa.toLowerCase(), ai);
                n(T, {
                    todo: ad
                }, ai, aj)
            });
            O(Z, Y ? ac : ac[0])
        }
        this.polyline = function(Y) {
            M(Y, "Polyline", "path")
        };
        this.polygon = function(Y) {
            M(Y, "Polygon", "paths")
        };
        this.trafficlayer = function(Y) {
            L();
            var Z = V.get("trafficlayer");
            if (!Z) {
                Z = new z.classes.TrafficLayer();
                Z.setMap(N);
                V.add(Y, "trafficlayer", Z)
            }
            O(Y, Z)
        };
        this.bicyclinglayer = function(Y) {
            L();
            var Z = V.get("bicyclinglayer");
            if (!Z) {
                Z = new z.classes.BicyclingLayer();
                Z.setMap(N);
                V.add(Y, "bicyclinglayer", Z)
            }
            O(Y, Z)
        };
        this.groundoverlay = function(Y) {
            Y.opts.bounds = j(Y.opts.bounds);
            if (Y.opts.bounds) {
                L(Y.opts.bounds.getCenter())
            }
            var aa, Z = new z.classes.GroundOverlay(Y.opts.url, Y.opts.bounds, Y.opts.opts);
            Z.setMap(N);
            aa = V.add(Y, "groundoverlay", Z);
            O(Y, Z, aa)
        };
        this.streetviewpanorama = function(Y) {
            if (!Y.opts.opts) {
                Y.opts.opts = {}
            }
            if (Y.latLng) {
                Y.opts.opts.position = Y.latLng
            } else {
                if (Y.opts.opts.position) {
                    Y.opts.opts.position = I(Y.opts.opts.position)
                }
            }
            if (Y.todo.divId) {
                Y.opts.container = document.getElementById(Y.todo.divId)
            } else {
                if (Y.opts.container) {
                    Y.opts.container = y(Y.opts.container).get(0)
                }
            }
            var aa, Z = new z.classes.StreetViewPanorama(Y.opts.container, Y.opts.opts);
            if (Z) {
                N.setStreetView(Z)
            }
            aa = V.add(Y, "streetviewpanorama", Z);
            O(Y, Z, aa)
        };
        this.kmllayer = function(Z) {
            var aa = [],
                Y = "values" in Z.todo;
            if (!Y) {
                Z.todo.values = [{
                    options: Z.opts
                }]
            }
            if (!Z.todo.values.length) {
                O(Z, false);
                return
            }
            y.each(Z.todo.values, function(ad, ae) {
                var ag, af, ac, ab = b(Z, ae);
                if (!N) {
                    L()
                }
                ac = ab.options;
                if (ab.options.opts) {
                    ac = ab.options.opts;
                    if (ab.options.url) {
                        ac.url = ab.options.url
                    }
                }
                ac.map = N;
                if (d("3.10")) {
                    af = new z.classes.KmlLayer(ac)
                } else {
                    af = new z.classes.KmlLayer(ac.url, ac)
                }
                aa.push(af);
                ag = V.add({
                    todo: ab
                }, "kmllayer", af);
                n(T, {
                    todo: ab
                }, af, ag)
            });
            O(Z, Y ? aa : aa[0])
        };
        this.panel = function(ab) {
            L();
            var ad, Y = 0,
                ac = 0,
                aa, Z = y(document.createElement("div"));
            Z.css({
                position: "absolute",
                zIndex: 1000,
                visibility: "hidden"
            });
            if (ab.opts.content) {
                aa = y(ab.opts.content);
                Z.append(aa);
                T.first().prepend(Z);
                if (ab.opts.left !== t) {
                    Y = ab.opts.left
                } else {
                    if (ab.opts.right !== t) {
                        Y = T.width() - aa.width() - ab.opts.right
                    } else {
                        if (ab.opts.center) {
                            Y = (T.width() - aa.width()) / 2
                        }
                    }
                }
                if (ab.opts.top !== t) {
                    ac = ab.opts.top
                } else {
                    if (ab.opts.bottom !== t) {
                        ac = T.height() - aa.height() - ab.opts.bottom
                    } else {
                        if (ab.opts.middle) {
                            ac = (T.height() - aa.height()) / 2
                        }
                    }
                }
                Z.css({
                    top: ac,
                    left: Y,
                    visibility: "visible"
                })
            }
            ad = V.add(ab, "panel", Z);
            O(ab, Z, ad);
            Z = null
        };

        function W(aa) {
            var af = new F(T, N, aa),
                Y = {},
                ab = {},
                ae = [],
                ad = /^[0-9]+$/,
                ac, Z;
            for (Z in aa) {
                if (ad.test(Z)) {
                    ae.push(1 * Z);
                    ab[Z] = aa[Z];
                    ab[Z].width = ab[Z].width || 0;
                    ab[Z].height = ab[Z].height || 0
                } else {
                    Y[Z] = aa[Z]
                }
            }
            ae.sort(function(ah, ag) {
                return ah > ag
            });
            if (Y.calculator) {
                ac = function(ag) {
                    var ah = [];
                    y.each(ag, function(aj, ai) {
                        ah.push(af.value(ai))
                    });
                    return Y.calculator.apply(T, [ah])
                }
            } else {
                ac = function(ag) {
                    return ag.length
                }
            }
            af.error(function() {
                u.apply(S, arguments)
            });
            af.display(function(ag) {
                var ai, aj, am, ak, al, ah = ac(ag.indexes);
                if (aa.force || ah > 1) {
                    for (ai = 0; ai < ae.length; ai++) {
                        if (ae[ai] <= ah) {
                            aj = ab[ae[ai]]
                        }
                    }
                }
                if (aj) {
                    al = aj.offset || [-aj.width / 2, -aj.height / 2];
                    am = y.extend({}, Y);
                    am.options = y.extend({
                        pane: "overlayLayer",
                        content: aj.content ? aj.content.replace("CLUSTER_COUNT", ah) : "",
                        offset: {
                            x: ("x" in al ? al.x : al[0]) || 0,
                            y: ("y" in al ? al.y : al[1]) || 0
                        }
                    }, Y.options || {});
                    ak = S.overlay({
                        todo: am,
                        opts: am.options,
                        latLng: I(ag)
                    }, true);
                    am.options.pane = "floatShadow";
                    am.options.content = y(document.createElement("div")).width(aj.width + "px").height(aj.height + "px").css({
                        cursor: "pointer"
                    });
                    shadow = S.overlay({
                        todo: am,
                        opts: am.options,
                        latLng: I(ag)
                    }, true);
                    Y.data = {
                        latLng: I(ag),
                        markers: []
                    };
                    y.each(ag.indexes, function(ao, an) {
                        Y.data.markers.push(af.value(an));
                        if (af.markerIsSet(an)) {
                            af.marker(an).setMap(null)
                        }
                    });
                    n(T, {
                        todo: Y
                    }, shadow, t, {
                        main: ak,
                        shadow: shadow
                    });
                    af.store(ag, ak, shadow)
                } else {
                    y.each(ag.indexes, function(ao, an) {
                        af.marker(an).setMap(N)
                    })
                }
            });
            return af
        }
        this.marker = function(aa) {
            var Y = "values" in aa.todo,
                ad = !N;
            if (!Y) {
                aa.opts.position = aa.latLng || I(aa.opts.position);
                aa.todo.values = [{
                    options: aa.opts
                }]
            }
            if (!aa.todo.values.length) {
                O(aa, false);
                return
            }
            if (ad) {
                L()
            }
            if (aa.todo.cluster && !N.getBounds()) {
                google.maps.event.addListenerOnce(N, "bounds_changed", function() {
                    S.marker.apply(S, [aa])
                });
                return
            }
            if (aa.todo.cluster) {
                var Z, ab;
                if (aa.todo.cluster instanceof a) {
                    Z = aa.todo.cluster;
                    ab = V.getById(Z.id(), true)
                } else {
                    ab = W(aa.todo.cluster);
                    Z = new a(k(aa.todo.id, true), ab);
                    V.add(aa, "clusterer", Z, ab)
                }
                ab.beginUpdate();
                y.each(aa.todo.values, function(af, ag) {
                    var ae = b(aa, ag);
                    ae.options.position = ae.options.position ? I(ae.options.position) : I(ag);
                    ae.options.map = N;
                    if (ad) {
                        N.setCenter(ae.options.position);
                        ad = false
                    }
                    ab.add(ae, ag)
                });
                ab.endUpdate();
                O(aa, Z)
            } else {
                var ac = [];
                y.each(aa.todo.values, function(af, ag) {
                    var ai, ah, ae = b(aa, ag);
                    ae.options.position = ae.options.position ? I(ae.options.position) : I(ag);
                    ae.options.map = N;
                    if (ad) {
                        N.setCenter(ae.options.position);
                        ad = false
                    }
                    ah = new z.classes.Marker(ae.options);
                    ac.push(ah);
                    ai = V.add({
                        todo: ae
                    }, "marker", ah);
                    n(T, {
                        todo: ae
                    }, ah, ai)
                });
                O(aa, Y ? ac : ac[0])
            }
        };
        this.getroute = function(Y) {
            Y.opts.origin = I(Y.opts.origin, true);
            Y.opts.destination = I(Y.opts.destination, true);
            G().route(Y.opts, function(aa, Z) {
                X(Y, Z == google.maps.DirectionsStatus.OK ? aa : false, Z);
                P.ack()
            })
        };
        this.directionsrenderer = function(Y) {
            Y.opts.map = N;
            var aa, Z = new google.maps.DirectionsRenderer(Y.opts);
            if (Y.todo.divId) {
                Z.setPanel(document.getElementById(Y.todo.divId))
            } else {
                if (Y.todo.container) {
                    Z.setPanel(y(Y.todo.container).get(0))
                }
            }
            aa = V.add(Y, "directionsrenderer", Z);
            O(Y, Z, aa)
        };
        this.getgeoloc = function(Y) {
            O(Y, Y.latLng)
        };
        this.styledmaptype = function(Y) {
            L();
            var Z = new z.classes.StyledMapType(Y.todo.styles, Y.opts);
            N.mapTypes.set(Y.todo.id, Z);
            O(Y, Z)
        };
        this.imagemaptype = function(Y) {
            L();
            var Z = new z.classes.ImageMapType(Y.opts);
            N.mapTypes.set(Y.todo.id, Z);
            O(Y, Z)
        };
        this.autofit = function(Y) {
            var Z = new google.maps.LatLngBounds();
            y.each(V.all(), function(aa, ab) {
                if (ab.getPosition) {
                    Z.extend(ab.getPosition())
                } else {
                    if (ab.getBounds) {
                        Z.extend(ab.getBounds().getNorthEast());
                        Z.extend(ab.getBounds().getSouthWest())
                    } else {
                        if (ab.getPaths) {
                            ab.getPaths().forEach(function(ac) {
                                ac.forEach(function(ad) {
                                    Z.extend(ad)
                                })
                            })
                        } else {
                            if (ab.getPath) {
                                ab.getPath().forEach(function(ac) {
                                    Z.extend(ac);
                                    ""
                                })
                            } else {
                                if (ab.getCenter) {
                                    Z.extend(ab.getCenter())
                                } else {
                                    if (ab instanceof a) {
                                        ab = V.getById(ab.id(), true);
                                        if (ab) {
                                            ab.autofit(Z)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            });
            if (!Z.isEmpty() && (!N.getBounds() || !N.getBounds().equals(Z))) {
                if ("maxZoom" in Y.todo) {
                    google.maps.event.addListenerOnce(N, "bounds_changed", function() {
                        if (this.getZoom() > Y.todo.maxZoom) {
                            this.setZoom(Y.todo.maxZoom)
                        }
                    })
                }
                N.fitBounds(Z)
            }
            O(Y, true)
        };
        this.clear = function(Y) {
            if (typeof Y.todo === "string") {
                if (V.clearById(Y.todo) || V.objClearById(Y.todo)) {
                    O(Y, true);
                    return
                }
                Y.todo = {
                    name: Y.todo
                }
            }
            if (Y.todo.id) {
                y.each(g(Y.todo.id), function(Z, aa) {
                    V.clearById(aa) || V.objClearById(aa)
                })
            } else {
                V.clear(g(Y.todo.name), Y.todo.last, Y.todo.first, Y.todo.tag);
                V.objClear(g(Y.todo.name), Y.todo.last, Y.todo.first, Y.todo.tag)
            }
            O(Y, true)
        };
        this.exec = function(Y) {
            var Z = this;
            y.each(g(Y.todo.func), function(aa, ab) {
                y.each(Z.get(Y.todo, true, Y.todo.hasOwnProperty("full") ? Y.todo.full : true), function(ac, ad) {
                    ab.call(T, ad)
                })
            });
            O(Y, true)
        };
        this.get = function(aa, ad, ac) {
            var Z, ab, Y = ad ? aa : aa.todo;
            if (!ad) {
                ac = Y.full
            }
            if (typeof Y === "string") {
                ab = V.getById(Y, false, ac) || V.objGetById(Y);
                if (ab === false) {
                    Z = Y;
                    Y = {}
                }
            } else {
                Z = Y.name
            }
            if (Z === "map") {
                ab = N
            }
            if (!ab) {
                ab = [];
                if (Y.id) {
                    y.each(g(Y.id), function(ae, af) {
                        ab.push(V.getById(af, false, ac) || V.objGetById(af))
                    });
                    if (!y.isArray(Y.id)) {
                        ab = ab[0]
                    }
                } else {
                    y.each(Z ? g(Z) : [t], function(af, ag) {
                        var ae;
                        if (Y.first) {
                            ae = V.get(ag, false, Y.tag, ac);
                            if (ae) {
                                ab.push(ae)
                            }
                        } else {
                            if (Y.all) {
                                y.each(V.all(ag, Y.tag, ac), function(ai, ah) {
                                    ab.push(ah)
                                })
                            } else {
                                ae = V.get(ag, true, Y.tag, ac);
                                if (ae) {
                                    ab.push(ae)
                                }
                            }
                        }
                    });
                    if (!Y.all && !y.isArray(Z)) {
                        ab = ab[0]
                    }
                }
            }
            ab = y.isArray(ab) || !Y.all ? ab : [ab];
            if (ad) {
                return ab
            } else {
                O(aa, ab)
            }
        };
        this.getdistance = function(Y) {
            var Z;
            Y.opts.origins = g(Y.opts.origins);
            for (Z = 0; Z < Y.opts.origins.length; Z++) {
                Y.opts.origins[Z] = I(Y.opts.origins[Z], true)
            }
            Y.opts.destinations = g(Y.opts.destinations);
            for (Z = 0; Z < Y.opts.destinations.length; Z++) {
                Y.opts.destinations[Z] = I(Y.opts.destinations[Z], true)
            }
            B().getDistanceMatrix(Y.opts, function(ab, aa) {
                X(Y, aa === google.maps.DistanceMatrixStatus.OK ? ab : false, aa);
                P.ack()
            })
        };
        this.trigger = function(Z) {
            if (typeof Z.todo === "string") {
                google.maps.event.trigger(N, Z.todo)
            } else {
                var Y = [N, Z.todo.eventName];
                if (Z.todo.var_args) {
                    y.each(Z.todo.var_args, function(ab, aa) {
                        Y.push(aa)
                    })
                }
                google.maps.event.trigger.apply(google.maps.event, Y)
            }
            X(Z);
            P.ack()
        }
    }

    function s(M) {
        var L;
        if (!typeof M === "object" || !M.hasOwnProperty("get")) {
            return false
        }
        for (L in M) {
            if (L !== "get") {
                return false
            }
        }
        return !M.get.hasOwnProperty("callback")
    }
    y.fn.gmap3 = function() {
        var M, O = [],
            N = true,
            L = [];
        J();
        for (M = 0; M < arguments.length; M++) {
            if (arguments[M]) {
                O.push(arguments[M])
            }
        }
        if (!O.length) {
            O.push("map")
        }
        y.each(this, function() {
            var P = y(this),
                Q = P.data("gmap3");
            N = false;
            if (!Q) {
                Q = new K(P);
                P.data("gmap3", Q)
            }
            if (O.length === 1 && (O[0] === "get" || s(O[0]))) {
                if (O[0] === "get") {
                    L.push(Q.get("map", true))
                } else {
                    L.push(Q.get(O[0].get, true, O[0].get.full))
                }
            } else {
                Q._plan(O)
            }
        });
        if (L.length) {
            if (L.length === 1) {
                return L[0]
            } else {
                return L
            }
        }
        return this
    }
})(jQuery);