diff --git a/enabler/src/de/schildbach/pte/AbstractHafasLegacyProvider.java b/enabler/src/de/schildbach/pte/AbstractHafasLegacyProvider.java
new file mode 100644
index 00000000..33724673
--- /dev/null
+++ b/enabler/src/de/schildbach/pte/AbstractHafasLegacyProvider.java
@@ -0,0 +1,3044 @@
+/*
+ * Copyright 2010-2017 the original author or authors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package de.schildbach.pte;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.EnumSet;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.GZIPInputStream;
+
+import javax.annotation.Nullable;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Strings;
+
+import de.schildbach.pte.dto.Departure;
+import de.schildbach.pte.dto.Line;
+import de.schildbach.pte.dto.Line.Attr;
+import de.schildbach.pte.dto.Location;
+import de.schildbach.pte.dto.LocationType;
+import de.schildbach.pte.dto.NearbyLocationsResult;
+import de.schildbach.pte.dto.Point;
+import de.schildbach.pte.dto.Position;
+import de.schildbach.pte.dto.Product;
+import de.schildbach.pte.dto.QueryDeparturesResult;
+import de.schildbach.pte.dto.QueryTripsContext;
+import de.schildbach.pte.dto.QueryTripsResult;
+import de.schildbach.pte.dto.ResultHeader;
+import de.schildbach.pte.dto.StationDepartures;
+import de.schildbach.pte.dto.Stop;
+import de.schildbach.pte.dto.SuggestLocationsResult;
+import de.schildbach.pte.dto.SuggestedLocation;
+import de.schildbach.pte.dto.Trip;
+import de.schildbach.pte.exception.ParserException;
+import de.schildbach.pte.exception.SessionExpiredException;
+import de.schildbach.pte.util.HttpClient;
+import de.schildbach.pte.util.LittleEndianDataInputStream;
+import de.schildbach.pte.util.ParserUtils;
+import de.schildbach.pte.util.StringReplaceReader;
+import de.schildbach.pte.util.XmlPullUtil;
+
+import okhttp3.HttpUrl;
+import okhttp3.ResponseBody;
+
+/**
+ * @author Andreas Schildbach
+ */
+public abstract class AbstractHafasLegacyProvider extends AbstractHafasProvider {
+    private static final String REQC_PROD = "hafas";
+
+    protected HttpUrl stationBoardEndpoint;
+    protected HttpUrl getStopEndpoint;
+    protected HttpUrl queryEndpoint;
+    private @Nullable HttpUrl extXmlEndpoint = null;
+    protected final String apiLanguage;
+    private @Nullable String accessId = null;
+    private @Nullable String clientType = "ANDROID";
+    private boolean jsonGetStopsUseWeight = true;
+    private Charset jsonNearbyLocationsEncoding = Charsets.ISO_8859_1;
+    private boolean dominantPlanStopTime = false;
+    private boolean useIso8601 = false;
+    private boolean stationBoardHasStationTable = true;
+    private boolean stationBoardHasLocation = false;
+    private boolean stationBoardCanDoEquivs = true;
+
+    @SuppressWarnings("serial")
+    private static class Context implements QueryTripsContext {
+        public final String laterContext;
+        public final String earlierContext;
+        public final int sequence;
+
+        public Context(final String laterContext, final String earlierContext, final int sequence) {
+            this.laterContext = laterContext;
+            this.earlierContext = earlierContext;
+            this.sequence = sequence;
+        }
+
+        @Override
+        public boolean canQueryLater() {
+            return laterContext != null;
+        }
+
+        @Override
+        public boolean canQueryEarlier() {
+            return earlierContext != null;
+        }
+    }
+
+    @SuppressWarnings("serial")
+    public static class QueryTripsBinaryContext implements QueryTripsContext {
+        public final String ident;
+        public final int seqNr;
+        public final String ld;
+        public final int usedBufferSize;
+        private final boolean canQueryMore;
+
+        public QueryTripsBinaryContext(final String ident, final int seqNr, final String ld, final int usedBufferSize,
+                final boolean canQueryMore) {
+            this.ident = ident;
+            this.seqNr = seqNr;
+            this.ld = ld;
+            this.usedBufferSize = usedBufferSize;
+            this.canQueryMore = canQueryMore;
+        }
+
+        @Override
+        public boolean canQueryLater() {
+            return canQueryMore;
+        }
+
+        @Override
+        public boolean canQueryEarlier() {
+            return canQueryMore;
+        }
+    }
+
+    public AbstractHafasLegacyProvider(final NetworkId network, final HttpUrl apiBase, final String apiLanguage,
+            final Product[] productsMap) {
+        super(network, productsMap);
+        this.stationBoardEndpoint = apiBase.newBuilder().addPathSegment("stboard.exe").build();
+        this.getStopEndpoint = apiBase.newBuilder().addPathSegment("ajax-getstop.exe").build();
+        this.queryEndpoint = apiBase.newBuilder().addPathSegment("query.exe").build();
+        this.apiLanguage = apiLanguage;
+    }
+
+    protected AbstractHafasProvider setStationBoardEndpoint(final HttpUrl stationBoardEndpoint) {
+        this.stationBoardEndpoint = stationBoardEndpoint;
+        return this;
+    }
+
+    protected AbstractHafasProvider setGetStopEndpoint(final HttpUrl getStopEndpoint) {
+        this.getStopEndpoint = getStopEndpoint;
+        return this;
+    }
+
+    protected AbstractHafasProvider setQueryEndpoint(final HttpUrl queryEndpoint) {
+        this.queryEndpoint = queryEndpoint;
+        return this;
+    }
+
+    protected AbstractHafasProvider setExtXmlEndpoint(final HttpUrl extXmlEndpoint) {
+        this.extXmlEndpoint = extXmlEndpoint;
+        return this;
+    }
+
+    protected AbstractHafasProvider setAccessId(final String accessId) {
+        this.accessId = accessId;
+        return this;
+    }
+
+    protected AbstractHafasProvider setClientType(final String clientType) {
+        this.clientType = clientType;
+        return this;
+    }
+
+    protected AbstractHafasProvider setDominantPlanStopTime(final boolean dominantPlanStopTime) {
+        this.dominantPlanStopTime = dominantPlanStopTime;
+        return this;
+    }
+
+    protected AbstractHafasProvider setJsonGetStopsUseWeight(final boolean jsonGetStopsUseWeight) {
+        this.jsonGetStopsUseWeight = jsonGetStopsUseWeight;
+        return this;
+    }
+
+    protected AbstractHafasProvider setJsonNearbyLocationsEncoding(final Charset jsonNearbyLocationsEncoding) {
+        this.jsonNearbyLocationsEncoding = jsonNearbyLocationsEncoding;
+        return this;
+    }
+
+    protected AbstractHafasProvider setUseIso8601(final boolean useIso8601) {
+        this.useIso8601 = useIso8601;
+        return this;
+    }
+
+    protected AbstractHafasProvider setStationBoardHasStationTable(final boolean stationBoardHasStationTable) {
+        this.stationBoardHasStationTable = stationBoardHasStationTable;
+        return this;
+    }
+
+    protected AbstractHafasProvider setStationBoardHasLocation(final boolean stationBoardHasLocation) {
+        this.stationBoardHasLocation = stationBoardHasLocation;
+        return this;
+    }
+
+    protected AbstractHafasProvider setStationBoardCanDoEquivs(final boolean canDoEquivs) {
+        this.stationBoardCanDoEquivs = canDoEquivs;
+        return this;
+    }
+
+    private final String wrapReqC(final CharSequence request, final Charset encoding) {
+        return "<?xml version=\"1.0\" encoding=\"" + (encoding != null ? encoding.name() : "iso-8859-1") + "\"?>" //
+                + "<ReqC ver=\"1.1\" prod=\"" + REQC_PROD + "\" lang=\"DE\""
+                + (accessId != null ? " accessId=\"" + accessId + "\"" : "") + ">" //
+                + request //
+                + "</ReqC>";
+    }
+
+    private final Location parseStation(final XmlPullParser pp) {
+        final String type = pp.getName();
+        if ("Station".equals(type)) {
+            final String name = XmlPullUtil.attr(pp, "name");
+            final String id = XmlPullUtil.attr(pp, "externalStationNr");
+            final int x = XmlPullUtil.intAttr(pp, "x");
+            final int y = XmlPullUtil.intAttr(pp, "y");
+
+            final String[] placeAndName = splitStationName(name);
+            return new Location(LocationType.STATION, id, y, x, placeAndName[0], placeAndName[1]);
+        }
+        throw new IllegalStateException("cannot handle: " + type);
+    }
+
+    private static final Location parsePoi(final XmlPullParser pp) {
+        final String type = pp.getName();
+        if ("Poi".equals(type)) {
+            String name = XmlPullUtil.attr(pp, "name");
+            if (name.equals("unknown"))
+                name = null;
+            final int x = XmlPullUtil.intAttr(pp, "x");
+            final int y = XmlPullUtil.intAttr(pp, "y");
+            return new Location(LocationType.POI, null, y, x, null, name);
+        }
+        throw new IllegalStateException("cannot handle: " + type);
+    }
+
+    private final Location parseAddress(final XmlPullParser pp) {
+        final String type = pp.getName();
+        if ("Address".equals(type)) {
+            String name = XmlPullUtil.attr(pp, "name");
+            if (name.equals("unknown"))
+                name = null;
+            final int x = XmlPullUtil.intAttr(pp, "x");
+            final int y = XmlPullUtil.intAttr(pp, "y");
+
+            final String[] placeAndName = splitAddress(name);
+            return new Location(LocationType.ADDRESS, null, y, x, placeAndName[0], placeAndName[1]);
+        }
+        throw new IllegalStateException("cannot handle: " + type);
+    }
+
+    private final Position parsePlatform(final XmlPullParser pp) throws XmlPullParserException, IOException {
+        XmlPullUtil.enter(pp, "Platform");
+        final String platformText = XmlPullUtil.valueTag(pp, "Text");
+        XmlPullUtil.skipExit(pp, "Platform");
+
+        if (platformText == null || platformText.length() == 0)
+            return null;
+        else
+            return parsePosition(platformText);
+    }
+
+    @Override
+    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
+        final HttpUrl.Builder url = getStopEndpoint.newBuilder().addPathSegment(apiLanguage);
+        appendJsonGetStopsParameters(url, checkNotNull(constraint), 0);
+        return jsonGetStops(url.build());
+    }
+
+    protected void appendJsonGetStopsParameters(final HttpUrl.Builder url, final CharSequence constraint,
+            final int maxStops) {
+        url.addQueryParameter("getstop", "1");
+        url.addQueryParameter("REQ0JourneyStopsS0A", "255");
+        url.addEncodedQueryParameter("REQ0JourneyStopsS0G",
+                ParserUtils.urlEncode(constraint.toString() + "?", requestUrlEncoding));
+        if (maxStops > 0)
+            url.addQueryParameter("REQ0JourneyStopsB", Integer.toString(maxStops));
+        url.addQueryParameter("js", "true");
+    }
+
+    private static final Pattern P_AJAX_GET_STOPS_JSON = Pattern
+            .compile("SLs\\.sls\\s*=\\s*(.*?);\\s*SLs\\.showSuggestion\\(\\);", Pattern.DOTALL);
+    private static final Pattern P_AJAX_GET_STOPS_ID = Pattern.compile(".*?@L=0*(\\d+)@.*?");
+
+    protected final SuggestLocationsResult jsonGetStops(final HttpUrl url) throws IOException {
+        final CharSequence page = httpClient.get(url);
+
+        final Matcher mJson = P_AJAX_GET_STOPS_JSON.matcher(page);
+        if (mJson.matches()) {
+            final String json = mJson.group(1);
+            final List<SuggestedLocation> locations = new ArrayList<SuggestedLocation>();
+
+            try {
+                final JSONObject head = new JSONObject(json);
+                final JSONArray aSuggestions = head.getJSONArray("suggestions");
+
+                for (int i = 0; i < aSuggestions.length(); i++) {
+                    final JSONObject suggestion = aSuggestions.optJSONObject(i);
+                    if (suggestion != null) {
+                        final int type = suggestion.getInt("type");
+                        final String value = suggestion.getString("value");
+                        final int lat = suggestion.optInt("ycoord");
+                        final int lon = suggestion.optInt("xcoord");
+                        final int weight = jsonGetStopsUseWeight ? suggestion.getInt("weight") : -i;
+                        String localId = null;
+                        final Matcher m = P_AJAX_GET_STOPS_ID.matcher(suggestion.getString("id"));
+                        if (m.matches())
+                            localId = m.group(1);
+
+                        final Location location;
+
+                        if (type == 1) // station
+                        {
+                            final String[] placeAndName = splitStationName(value);
+                            location = new Location(LocationType.STATION, localId, lat, lon, placeAndName[0],
+                                    placeAndName[1]);
+                        } else if (type == 2) // address
+                        {
+                            final String[] placeAndName = splitAddress(value);
+                            location = new Location(LocationType.ADDRESS, null, lat, lon, placeAndName[0],
+                                    placeAndName[1]);
+                        } else if (type == 4) // poi
+                        {
+                            final String[] placeAndName = splitPOI(value);
+                            location = new Location(LocationType.POI, localId, lat, lon, placeAndName[0],
+                                    placeAndName[1]);
+                        } else if (type == 128) // crossing
+                        {
+                            final String[] placeAndName = splitAddress(value);
+                            location = new Location(LocationType.ADDRESS, localId, lat, lon, placeAndName[0],
+                                    placeAndName[1]);
+                        } else if (type == 87) {
+                            location = null;
+                            // don't know what to do
+                        } else {
+                            throw new IllegalStateException("unknown type " + type + " on " + url);
+                        }
+
+                        if (location != null) {
+                            final SuggestedLocation suggestedLocation = new SuggestedLocation(location, weight);
+                            locations.add(suggestedLocation);
+                        }
+                    }
+                }
+
+                return new SuggestLocationsResult(new ResultHeader(network, SERVER_PRODUCT), locations);
+            } catch (final JSONException x) {
+                throw new RuntimeException("cannot parse: '" + json + "' on " + url, x);
+            }
+        } else {
+            throw new RuntimeException("cannot parse: '" + page + "' on " + url);
+        }
+    }
+
+    @Override
+    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
+            final int maxDepartures, final boolean equivs) throws IOException {
+        checkNotNull(Strings.emptyToNull(stationId));
+
+        final HttpUrl.Builder url = stationBoardEndpoint.newBuilder().addPathSegment(apiLanguage);
+        appendXmlStationBoardParameters(url, time, stationId, maxDepartures, equivs, "vs_java3");
+        return xmlStationBoard(url.build(), stationId);
+    }
+
+    protected void appendXmlStationBoardParameters(final HttpUrl.Builder url, final @Nullable Date time,
+            final String stationId, final int maxDepartures, final boolean equivs, final @Nullable String styleSheet) {
+        url.addQueryParameter("productsFilter", allProductsString().toString());
+        url.addQueryParameter("boardType", "dep");
+        if (stationBoardCanDoEquivs)
+            url.addQueryParameter("disableEquivs", equivs ? "0" : "1");
+        url.addQueryParameter("maxJourneys",
+                Integer.toString(maxDepartures > 0 ? maxDepartures : DEFAULT_MAX_DEPARTURES));
+        url.addEncodedQueryParameter("input", ParserUtils.urlEncode(normalizeStationId(stationId), requestUrlEncoding));
+        appendDateTimeParameters(url, time, "date", "time");
+        if (clientType != null)
+            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
+        if (styleSheet != null)
+            url.addQueryParameter("L", styleSheet);
+        url.addQueryParameter("hcount", "0"); // prevents showing old departures
+        url.addQueryParameter("start", "yes");
+    }
+
+    protected void appendDateTimeParameters(final HttpUrl.Builder url, final Date time, final String dateParamName,
+            final String timeParamName) {
+        final Calendar c = new GregorianCalendar(timeZone);
+        c.setTime(time);
+        final int year = c.get(Calendar.YEAR);
+        final int month = c.get(Calendar.MONTH) + 1;
+        final int day = c.get(Calendar.DAY_OF_MONTH);
+        final int hour = c.get(Calendar.HOUR_OF_DAY);
+        final int minute = c.get(Calendar.MINUTE);
+        url.addEncodedQueryParameter(dateParamName,
+                ParserUtils.urlEncode(
+                        useIso8601 ? String.format(Locale.ENGLISH, "%04d-%02d-%02d", year, month, day)
+                                : String.format(Locale.ENGLISH, "%02d.%02d.%02d", day, month, year - 2000),
+                        requestUrlEncoding));
+        url.addEncodedQueryParameter(timeParamName,
+                ParserUtils.urlEncode(String.format(Locale.ENGLISH, "%02d:%02d", hour, minute), requestUrlEncoding));
+    }
+
+    private static final Pattern P_XML_STATION_BOARD_DELAY = Pattern.compile("(?:-|k\\.A\\.?|cancel|([+-]?\\s*\\d+))");
+
+    protected final QueryDeparturesResult xmlStationBoard(final HttpUrl url, final String stationId)
+            throws IOException {
+        final String normalizedStationId = normalizeStationId(stationId);
+        final AtomicReference<QueryDeparturesResult> result = new AtomicReference<QueryDeparturesResult>();
+
+        httpClient.getInputStream(new HttpClient.Callback() {
+
+            @Override
+            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
+                StringReplaceReader reader = null;
+                String firstChars = null;
+
+                // work around unparsable XML
+                reader = new StringReplaceReader(body.charStream(), " & ", " &amp; ");
+                reader.replace("<b>", " ");
+                reader.replace("</b>", " ");
+                reader.replace("<u>", " ");
+                reader.replace("</u>", " ");
+                reader.replace("<i>", " ");
+                reader.replace("</i>", " ");
+                reader.replace("<br />", " ");
+                reader.replace(" ->", " &#x2192;"); // right arrow
+                reader.replace(" <-", " &#x2190;"); // left arrow
+                reader.replace(" <> ", " &#x2194; "); // left-right arrow
+                addCustomReplaces(reader);
+
+                try {
+                    final XmlPullParserFactory factory = XmlPullParserFactory
+                            .newInstance(System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
+                    final XmlPullParser pp = factory.newPullParser();
+                    pp.setInput(reader);
+
+                    pp.nextTag();
+
+                    final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+                    final QueryDeparturesResult r = new QueryDeparturesResult(header);
+
+                    if (XmlPullUtil.test(pp, "Err")) {
+                        final String code = XmlPullUtil.attr(pp, "code");
+                        final String text = XmlPullUtil.attr(pp, "text");
+
+                        if (code.equals("H730")) {
+                            result.set(new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION));
+                            return;
+                        }
+                        if (code.equals("H890")) {
+                            r.stationDepartures
+                                    .add(new StationDepartures(new Location(LocationType.STATION, normalizedStationId),
+                                            Collections.<Departure> emptyList(), null));
+                            result.set(r);
+                            return;
+                        }
+                        throw new IllegalArgumentException("unknown error " + code + ", " + text);
+                    }
+
+                    String[] stationPlaceAndName = null;
+
+                    if (stationBoardHasStationTable)
+                        XmlPullUtil.enter(pp, "StationTable");
+                    else
+                        checkState(!XmlPullUtil.test(pp, "StationTable"));
+
+                    if (stationBoardHasLocation) {
+                        XmlPullUtil.require(pp, "St");
+
+                        final String evaId = XmlPullUtil.attr(pp, "evaId");
+                        if (evaId != null) {
+                            if (!evaId.equals(normalizedStationId))
+                                throw new IllegalStateException(
+                                        "stationId: " + normalizedStationId + ", evaId: " + evaId);
+
+                            final String name = XmlPullUtil.attr(pp, "name");
+                            if (name != null)
+                                stationPlaceAndName = splitStationName(name.trim());
+                        }
+                        XmlPullUtil.requireSkip(pp, "St");
+                    } else {
+                        checkState(!XmlPullUtil.test(pp, "St"));
+                    }
+
+                    while (XmlPullUtil.test(pp, "Journey")) {
+                        final String fpTime = XmlPullUtil.attr(pp, "fpTime");
+                        final String fpDate = XmlPullUtil.attr(pp, "fpDate");
+                        final String delay = XmlPullUtil.attr(pp, "delay");
+                        final String eDelay = XmlPullUtil.optAttr(pp, "e_delay", null);
+                        final String platform = XmlPullUtil.optAttr(pp, "platform", null);
+                        // TODO newpl
+                        final String targetLoc = XmlPullUtil.optAttr(pp, "targetLoc", null);
+                        // TODO hafasname
+                        final String dirnr = XmlPullUtil.optAttr(pp, "dirnr", null);
+                        final String prod = XmlPullUtil.attr(pp, "prod");
+                        final String classStr = XmlPullUtil.optAttr(pp, "class", null);
+                        final String dir = XmlPullUtil.optAttr(pp, "dir", null);
+                        final String capacityStr = XmlPullUtil.optAttr(pp, "capacity", null);
+                        final String depStation = XmlPullUtil.optAttr(pp, "depStation", null);
+                        final String delayReason = XmlPullUtil.optAttr(pp, "delayReason", null);
+                        // TODO is_reachable
+                        // TODO disableTrainInfo
+                        // TODO lineFG/lineBG (ZVV)
+                        final String administration = normalizeLineAdministration(
+                                XmlPullUtil.optAttr(pp, "administration", null));
+
+                        if (!"cancel".equals(delay) && !"cancel".equals(eDelay)) {
+                            final Calendar plannedTime = new GregorianCalendar(timeZone);
+                            plannedTime.clear();
+                            ParserUtils.parseEuropeanTime(plannedTime, fpTime);
+                            if (fpDate.length() == 8)
+                                ParserUtils.parseGermanDate(plannedTime, fpDate);
+                            else if (fpDate.length() == 10)
+                                ParserUtils.parseIsoDate(plannedTime, fpDate);
+                            else
+                                throw new IllegalStateException("cannot parse: '" + fpDate + "'");
+
+                            final Calendar predictedTime;
+                            if (eDelay != null) {
+                                predictedTime = new GregorianCalendar(timeZone);
+                                predictedTime.setTimeInMillis(plannedTime.getTimeInMillis());
+                                predictedTime.add(Calendar.MINUTE, Integer.parseInt(eDelay));
+                            } else if (delay != null) {
+                                final Matcher m = P_XML_STATION_BOARD_DELAY.matcher(delay);
+                                if (m.matches()) {
+                                    if (m.group(1) != null) {
+                                        predictedTime = new GregorianCalendar(timeZone);
+                                        predictedTime.setTimeInMillis(plannedTime.getTimeInMillis());
+                                        predictedTime.add(Calendar.MINUTE, Integer.parseInt(m.group(1)));
+                                    } else {
+                                        predictedTime = null;
+                                    }
+                                } else {
+                                    throw new RuntimeException("cannot parse delay: '" + delay + "'");
+                                }
+                            } else {
+                                predictedTime = null;
+                            }
+
+                            final Position position = parsePosition(ParserUtils.resolveEntities(platform));
+
+                            final String destinationName;
+                            if (dir != null)
+                                destinationName = dir.trim();
+                            else if (targetLoc != null)
+                                destinationName = targetLoc.trim();
+                            else
+                                destinationName = null;
+
+                            final Location destination;
+                            if (dirnr != null) {
+                                final String[] destinationPlaceAndName = splitStationName(destinationName);
+                                destination = new Location(LocationType.STATION, dirnr, destinationPlaceAndName[0],
+                                        destinationPlaceAndName[1]);
+                            } else {
+                                destination = new Location(LocationType.ANY, null, null, destinationName);
+                            }
+
+                            final Line prodLine = parseLineAndType(prod);
+                            final Line line;
+                            if (classStr != null) {
+                                final Product product = intToProduct(Integer.parseInt(classStr));
+                                if (product == null)
+                                    throw new IllegalArgumentException();
+                                // could check for type consistency here
+                                final Set<Attr> attrs = prodLine.attrs;
+                                if (attrs != null)
+                                    line = newLine(administration, product, prodLine.label, null,
+                                            attrs.toArray(new Line.Attr[0]));
+                                else
+                                    line = newLine(administration, product, prodLine.label, null);
+                            } else {
+                                final Set<Attr> attrs = prodLine.attrs;
+                                if (attrs != null)
+                                    line = newLine(administration, prodLine.product, prodLine.label, null,
+                                            attrs.toArray(new Line.Attr[0]));
+                                else
+                                    line = newLine(administration, prodLine.product, prodLine.label, null);
+                            }
+
+                            final int[] capacity;
+                            if (capacityStr != null && !"0|0".equals(capacityStr)) {
+                                final String[] capacityParts = capacityStr.split("\\|");
+                                capacity = new int[] { Integer.parseInt(capacityParts[0]),
+                                        Integer.parseInt(capacityParts[1]) };
+                            } else {
+                                capacity = null;
+                            }
+
+                            final String message;
+                            if (delayReason != null) {
+                                final String msg = delayReason.trim();
+                                message = msg.length() > 0 ? msg : null;
+                            } else {
+                                message = null;
+                            }
+
+                            final Departure departure = new Departure(plannedTime.getTime(),
+                                    predictedTime != null ? predictedTime.getTime() : null, line, position, destination,
+                                    capacity, message);
+
+                            final Location location;
+                            if (!stationBoardCanDoEquivs || depStation == null) {
+                                location = new Location(LocationType.STATION, normalizedStationId,
+                                        stationPlaceAndName != null ? stationPlaceAndName[0] : null,
+                                        stationPlaceAndName != null ? stationPlaceAndName[1] : null);
+                            } else {
+                                final String[] depPlaceAndName = splitStationName(depStation);
+                                location = new Location(LocationType.STATION, null, depPlaceAndName[0],
+                                        depPlaceAndName[1]);
+                            }
+
+                            StationDepartures stationDepartures = findStationDepartures(r.stationDepartures, location);
+                            if (stationDepartures == null) {
+                                stationDepartures = new StationDepartures(location, new ArrayList<Departure>(8), null);
+                                r.stationDepartures.add(stationDepartures);
+                            }
+
+                            stationDepartures.departures.add(departure);
+                        }
+
+                        XmlPullUtil.requireSkip(pp, "Journey");
+                    }
+
+                    if (stationBoardHasStationTable)
+                        XmlPullUtil.exit(pp, "StationTable");
+
+                    XmlPullUtil.requireEndDocument(pp);
+
+                    // sort departures
+                    for (final StationDepartures stationDepartures : r.stationDepartures)
+                        Collections.sort(stationDepartures.departures, Departure.TIME_COMPARATOR);
+
+                    result.set(r);
+                } catch (final XmlPullParserException x) {
+                    throw new ParserException("cannot parse xml: " + firstChars, x);
+                }
+            }
+        }, url);
+
+        return result.get();
+    }
+
+    protected void addCustomReplaces(final StringReplaceReader reader) {
+    }
+
+    @Override
+    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
+            final Date date, final boolean dep, final @Nullable Set<Product> products,
+            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
+            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
+        return queryTripsBinary(from, via, to, date, dep, products, walkSpeed, accessibility, options);
+    }
+
+    @Override
+    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
+        return queryMoreTripsBinary(context, later);
+    }
+
+    protected final QueryTripsResult queryTripsXml(Location from, @Nullable Location via, Location to, final Date date,
+            final boolean dep, final @Nullable Set<Product> products, final @Nullable WalkSpeed walkSpeed,
+            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
+        final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+
+        if (!from.isIdentified()) {
+            final List<Location> locations = suggestLocations(from.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, locations, null, null);
+            from = locations.get(0);
+        }
+
+        if (via != null && !via.isIdentified()) {
+            final List<Location> locations = suggestLocations(via.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, null, locations, null);
+            via = locations.get(0);
+        }
+
+        if (!to.isIdentified()) {
+            final List<Location> locations = suggestLocations(to.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, null, null, locations);
+            to = locations.get(0);
+        }
+
+        final Calendar c = new GregorianCalendar(timeZone);
+        c.setTime(date);
+
+        final CharSequence productsStr;
+        if (products != null)
+            productsStr = productsString(products);
+        else
+            productsStr = allProductsString();
+
+        final char bikeChar = (options != null && options.contains(Option.BIKE)) ? '1' : '0';
+
+        final StringBuilder conReq = new StringBuilder("<ConReq deliverPolyline=\"1\">");
+        conReq.append("<Start>").append(locationXml(from));
+        conReq.append("<Prod prod=\"").append(productsStr).append("\" bike=\"").append(bikeChar)
+                .append("\" couchette=\"0\" direct=\"0\" sleeper=\"0\"/>");
+        conReq.append("</Start>");
+        if (via != null) {
+            conReq.append("<Via>").append(locationXml(via));
+            if (via.type != LocationType.ADDRESS)
+                conReq.append("<Prod prod=\"").append(productsStr).append("\" bike=\"").append(bikeChar)
+                        .append("\" couchette=\"0\" direct=\"0\" sleeper=\"0\"/>");
+            conReq.append("</Via>");
+        }
+        conReq.append("<Dest>").append(locationXml(to)).append("</Dest>");
+        conReq.append("<ReqT a=\"").append(dep ? 0 : 1).append("\" date=\"")
+                .append(String.format(Locale.ENGLISH, "%04d.%02d.%02d", c.get(Calendar.YEAR), c.get(Calendar.MONTH) + 1,
+                        c.get(Calendar.DAY_OF_MONTH)))
+                .append("\" time=\"")
+                .append(String.format(Locale.ENGLISH, "%02d:%02d", c.get(Calendar.HOUR_OF_DAY), c.get(Calendar.MINUTE))
+                        + "\"/>");
+        conReq.append("<RFlags");
+        // number of trips backwards
+        conReq.append(" b=\"").append(0).append("\"");
+        // number of trips forwards
+        conReq.append(" f=\"").append(numTripsRequested).append("\"");
+        // percentual extension of change time
+        conReq.append(" chExtension=\"").append(walkSpeed == WalkSpeed.SLOW ? 50 : 0).append("\"");
+        // TODO nrChanges: max number of changes
+        conReq.append(" sMode=\"N\"/>");
+        conReq.append("</ConReq>");
+
+        return queryTripsXml(null, true, conReq, from, via, to);
+    }
+
+    protected final QueryTripsResult queryMoreTripsXml(final QueryTripsContext contextObj, final boolean later)
+            throws IOException {
+        final Context context = (Context) contextObj;
+
+        final StringBuilder conScrReq = new StringBuilder("<ConScrReq scrDir=\"").append(later ? 'F' : 'B')
+                .append("\" nrCons=\"").append(numTripsRequested).append("\">");
+        conScrReq.append("<ConResCtxt>").append(later ? context.laterContext : context.earlierContext)
+                .append("</ConResCtxt>");
+        conScrReq.append("</ConScrReq>");
+
+        return queryTripsXml(context, later, conScrReq, null, null, null);
+    }
+
+    private QueryTripsResult queryTripsXml(final Context previousContext, final boolean later,
+            final CharSequence conReq, final Location from, final @Nullable Location via, final Location to)
+            throws IOException {
+        final String request = wrapReqC(conReq, null);
+        final HttpUrl endpoint = extXmlEndpoint != null ? extXmlEndpoint
+                : queryEndpoint.newBuilder().addPathSegment(apiLanguage).build();
+        final AtomicReference<QueryTripsResult> result = new AtomicReference<QueryTripsResult>();
+        httpClient.getInputStream(new HttpClient.Callback() {
+            @Override
+            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
+                try {
+                    final XmlPullParserFactory factory = XmlPullParserFactory
+                            .newInstance(System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
+                    final XmlPullParser pp = factory.newPullParser();
+                    pp.setInput(body.charStream());
+
+                    XmlPullUtil.require(pp, "ResC");
+                    final String product = XmlPullUtil.attr(pp, "prod").split(" ")[0];
+                    final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, product, null, 0, null);
+                    XmlPullUtil.enter(pp, "ResC");
+
+                    if (XmlPullUtil.test(pp, "Err")) {
+                        final String code = XmlPullUtil.attr(pp, "code");
+                        if (code.equals("I3")) {
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
+                            return;
+                        }
+                        if (code.equals("F1")) {
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                            return;
+                        }
+                        throw new IllegalStateException("error " + code + " " + XmlPullUtil.attr(pp, "text"));
+                    }
+
+                    XmlPullUtil.enter(pp, "ConRes");
+
+                    if (XmlPullUtil.test(pp, "Err")) {
+                        final String code = XmlPullUtil.attr(pp, "code");
+                        log.debug("Hafas error: {}", code);
+                        if (code.equals("K9260")) {
+                            // Unknown departure station
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM));
+                            return;
+                        }
+                        if (code.equals("K9280")) {
+                            // Unknown intermediate station
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA));
+                            return;
+                        }
+                        if (code.equals("K9300")) {
+                            // Unknown arrival station
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO));
+                            return;
+                        }
+                        if (code.equals("K9360")) {
+                            // Date outside of the timetable period
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
+                            return;
+                        }
+                        if (code.equals("K9380")) {
+                            // Dep./Arr./Intermed. or equivalent station defined more than once
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
+                            return;
+                        }
+                        if (code.equals("K895")) {
+                            // Departure/Arrival are too near
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
+                            return;
+                        }
+                        if (code.equals("K9220")) {
+                            // Nearby to the given address stations could not be found
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS));
+                            return;
+                        }
+                        if (code.equals("K9240")) {
+                            // Internal error
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                            return;
+                        }
+                        if (code.equals("K890")) {
+                            // No connections found
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                            return;
+                        }
+                        if (code.equals("K891")) {
+                            // No route found (try entering an intermediate station)
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                            return;
+                        }
+                        if (code.equals("K899")) {
+                            // An error occurred
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                            return;
+                        }
+                        if (code.equals("K1:890")) {
+                            // Unsuccessful or incomplete search (direction: forward)
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                            return;
+                        }
+                        if (code.equals("K2:890")) {
+                            // Unsuccessful or incomplete search (direction: backward)
+                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                            return;
+                        }
+                        throw new IllegalStateException("error " + code + " " + XmlPullUtil.attr(pp, "text"));
+                    }
+
+                    // H9380 Dep./Arr./Intermed. or equivalent stations defined more than once
+                    // H9360 Error in data field
+                    // H9320 The input is incorrect or incomplete
+                    // H9300 Unknown arrival station
+                    // H9280 Unknown intermediate station
+                    // H9260 Unknown departure station
+                    // H9250 Part inquiry interrupted
+                    // H9240 Unsuccessful search
+                    // H9230 An internal error occurred
+                    // H9220 Nearby to the given address stations could not be found
+                    // H900 Unsuccessful or incomplete search (timetable change)
+                    // H892 Inquiry too complex (try entering less intermediate stations)
+                    // H891 No route found (try entering an intermediate station)
+                    // H890 Unsuccessful search.
+                    // H500 Because of too many trains the connection is not complete
+                    // H460 One or more stops are passed through multiple times.
+                    // H455 Prolonged stop
+                    // H410 Display may be incomplete due to change of timetable
+                    // H390 Departure/Arrival replaced by an equivalent station
+                    // H895 Departure/Arrival are too near
+                    // H899 Unsuccessful or incomplete search (timetable change
+
+                    final String c = XmlPullUtil.optValueTag(pp, "ConResCtxt", null);
+                    final Context context;
+                    if (previousContext == null)
+                        context = new Context(c, c, 0);
+                    else if (later)
+                        context = new Context(c, previousContext.earlierContext, previousContext.sequence + 1);
+                    else
+                        context = new Context(previousContext.laterContext, c, previousContext.sequence + 1);
+
+                    XmlPullUtil.enter(pp, "ConnectionList");
+
+                    final List<Trip> trips = new ArrayList<Trip>();
+
+                    while (XmlPullUtil.test(pp, "Connection")) {
+                        final String id = context.sequence + "/" + XmlPullUtil.attr(pp, "id");
+
+                        XmlPullUtil.enter(pp, "Connection");
+                        while (pp.getName().equals("RtStateList"))
+                            XmlPullUtil.next(pp);
+                        XmlPullUtil.enter(pp, "Overview");
+
+                        final Calendar currentDate = new GregorianCalendar(timeZone);
+                        currentDate.clear();
+                        parseDate(currentDate, XmlPullUtil.valueTag(pp, "Date"));
+                        XmlPullUtil.enter(pp, "Departure");
+                        XmlPullUtil.enter(pp, "BasicStop");
+                        while (pp.getName().equals("StAttrList"))
+                            XmlPullUtil.next(pp);
+                        final Location departureLocation = parseLocation(pp);
+                        XmlPullUtil.enter(pp, "Dep");
+                        XmlPullUtil.skipExit(pp, "Dep");
+                        final int[] capacity;
+                        if (XmlPullUtil.test(pp, "StopPrognosis")) {
+                            XmlPullUtil.enter(pp, "StopPrognosis");
+                            XmlPullUtil.optSkip(pp, "Arr");
+                            XmlPullUtil.optSkip(pp, "Dep");
+                            XmlPullUtil.enter(pp, "Status");
+                            XmlPullUtil.skipExit(pp, "Status");
+                            final int capacity1st = Integer.parseInt(XmlPullUtil.optValueTag(pp, "Capacity1st", "0"));
+                            final int capacity2nd = Integer.parseInt(XmlPullUtil.optValueTag(pp, "Capacity2nd", "0"));
+                            if (capacity1st > 0 || capacity2nd > 0)
+                                capacity = new int[] { capacity1st, capacity2nd };
+                            else
+                                capacity = null;
+                            XmlPullUtil.skipExit(pp, "StopPrognosis");
+                        } else {
+                            capacity = null;
+                        }
+                        XmlPullUtil.skipExit(pp, "BasicStop");
+                        XmlPullUtil.skipExit(pp, "Departure");
+
+                        XmlPullUtil.enter(pp, "Arrival");
+                        XmlPullUtil.enter(pp, "BasicStop");
+                        while (pp.getName().equals("StAttrList"))
+                            XmlPullUtil.next(pp);
+                        final Location arrivalLocation = parseLocation(pp);
+                        XmlPullUtil.skipExit(pp, "BasicStop");
+                        XmlPullUtil.skipExit(pp, "Arrival");
+
+                        final int numTransfers = Integer.parseInt(XmlPullUtil.valueTag(pp, "Transfers"));
+
+                        XmlPullUtil.skipExit(pp, "Overview");
+
+                        final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(4);
+
+                        XmlPullUtil.enter(pp, "ConSectionList");
+
+                        final Calendar time = new GregorianCalendar(timeZone);
+
+                        while (XmlPullUtil.test(pp, "ConSection")) {
+                            XmlPullUtil.enter(pp, "ConSection");
+
+                            // departure
+                            XmlPullUtil.enter(pp, "Departure");
+                            XmlPullUtil.enter(pp, "BasicStop");
+                            while (pp.getName().equals("StAttrList"))
+                                XmlPullUtil.next(pp);
+                            final Location sectionDepartureLocation = parseLocation(pp);
+
+                            XmlPullUtil.optSkip(pp, "Arr");
+                            XmlPullUtil.enter(pp, "Dep");
+                            time.setTimeInMillis(currentDate.getTimeInMillis());
+                            parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
+                            final Date departureTime = time.getTime();
+                            final Position departurePos = parsePlatform(pp);
+                            XmlPullUtil.skipExit(pp, "Dep");
+
+                            XmlPullUtil.skipExit(pp, "BasicStop");
+                            XmlPullUtil.skipExit(pp, "Departure");
+
+                            // journey
+                            final Line line;
+                            Location destination = null;
+
+                            List<Stop> intermediateStops = null;
+
+                            final String tag = pp.getName();
+                            if (tag.equals("Journey")) {
+                                XmlPullUtil.enter(pp, "Journey");
+                                while (pp.getName().equals("JHandle"))
+                                    XmlPullUtil.next(pp);
+                                XmlPullUtil.enter(pp, "JourneyAttributeList");
+                                boolean wheelchairAccess = false;
+                                String name = null;
+                                String category = null;
+                                String shortCategory = null;
+                                while (XmlPullUtil.test(pp, "JourneyAttribute")) {
+                                    XmlPullUtil.enter(pp, "JourneyAttribute");
+                                    XmlPullUtil.require(pp, "Attribute");
+                                    final String attrName = XmlPullUtil.attr(pp, "type");
+                                    final String code = XmlPullUtil.optAttr(pp, "code", null);
+                                    XmlPullUtil.enter(pp, "Attribute");
+                                    final Map<String, String> attributeVariants = parseAttributeVariants(pp);
+                                    XmlPullUtil.skipExit(pp, "Attribute");
+                                    XmlPullUtil.skipExit(pp, "JourneyAttribute");
+
+                                    if ("bf".equals(code)) {
+                                        wheelchairAccess = true;
+                                    } else if ("NAME".equals(attrName)) {
+                                        name = attributeVariants.get("NORMAL");
+                                    } else if ("CATEGORY".equals(attrName)) {
+                                        shortCategory = attributeVariants.get("SHORT");
+                                        category = attributeVariants.get("NORMAL");
+                                        // longCategory = attributeVariants.get("LONG");
+                                    } else if ("DIRECTION".equals(attrName)) {
+                                        final String[] destinationPlaceAndName = splitStationName(
+                                                attributeVariants.get("NORMAL"));
+                                        destination = new Location(LocationType.ANY, null, destinationPlaceAndName[0],
+                                                destinationPlaceAndName[1]);
+                                    }
+                                }
+                                XmlPullUtil.skipExit(pp, "JourneyAttributeList");
+
+                                if (XmlPullUtil.test(pp, "PassList")) {
+                                    intermediateStops = new LinkedList<Stop>();
+
+                                    XmlPullUtil.enter(pp, "PassList");
+                                    while (XmlPullUtil.test(pp, "BasicStop")) {
+                                        XmlPullUtil.enter(pp, "BasicStop");
+                                        while (XmlPullUtil.test(pp, "StAttrList"))
+                                            XmlPullUtil.next(pp);
+                                        final Location location = parseLocation(pp);
+                                        if (location.id != sectionDepartureLocation.id) {
+                                            Date stopArrivalTime = null;
+                                            Date stopDepartureTime = null;
+                                            Position stopArrivalPosition = null;
+                                            Position stopDeparturePosition = null;
+
+                                            if (XmlPullUtil.test(pp, "Arr")) {
+                                                XmlPullUtil.enter(pp, "Arr");
+                                                time.setTimeInMillis(currentDate.getTimeInMillis());
+                                                parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
+                                                stopArrivalTime = time.getTime();
+                                                stopArrivalPosition = parsePlatform(pp);
+                                                XmlPullUtil.skipExit(pp, "Arr");
+                                            }
+
+                                            if (XmlPullUtil.test(pp, "Dep")) {
+                                                XmlPullUtil.enter(pp, "Dep");
+                                                time.setTimeInMillis(currentDate.getTimeInMillis());
+                                                parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
+                                                stopDepartureTime = time.getTime();
+                                                stopDeparturePosition = parsePlatform(pp);
+                                                XmlPullUtil.skipExit(pp, "Dep");
+                                            }
+
+                                            intermediateStops.add(new Stop(location, stopArrivalTime,
+                                                    stopArrivalPosition, stopDepartureTime, stopDeparturePosition));
+                                        }
+                                        XmlPullUtil.skipExit(pp, "BasicStop");
+                                    }
+
+                                    XmlPullUtil.skipExit(pp, "PassList");
+                                }
+
+                                XmlPullUtil.skipExit(pp, "Journey");
+
+                                if (category == null)
+                                    category = shortCategory;
+
+                                line = parseLine(category, name, wheelchairAccess);
+                            } else if (tag.equals("Walk") || tag.equals("Transfer") || tag.equals("GisRoute")) {
+                                XmlPullUtil.enter(pp);
+                                XmlPullUtil.enter(pp, "Duration");
+                                XmlPullUtil.skipExit(pp, "Duration");
+                                XmlPullUtil.skipExit(pp);
+
+                                line = null;
+                            } else {
+                                throw new IllegalStateException("cannot handle: " + pp.getName());
+                            }
+
+                            // polyline
+                            final List<Point> path;
+                            if (XmlPullUtil.test(pp, "Polyline")) {
+                                path = new LinkedList<Point>();
+                                XmlPullUtil.enter(pp, "Polyline");
+                                while (XmlPullUtil.test(pp, "Point")) {
+                                    final int x = XmlPullUtil.intAttr(pp, "x");
+                                    final int y = XmlPullUtil.intAttr(pp, "y");
+                                    path.add(new Point(y, x));
+                                    XmlPullUtil.next(pp);
+                                }
+                                XmlPullUtil.skipExit(pp, "Polyline");
+                            } else {
+                                path = null;
+                            }
+
+                            // arrival
+                            XmlPullUtil.enter(pp, "Arrival");
+                            XmlPullUtil.enter(pp, "BasicStop");
+                            while (pp.getName().equals("StAttrList"))
+                                XmlPullUtil.next(pp);
+                            final Location sectionArrivalLocation = parseLocation(pp);
+                            XmlPullUtil.enter(pp, "Arr");
+                            time.setTimeInMillis(currentDate.getTimeInMillis());
+                            parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
+                            final Date arrivalTime = time.getTime();
+                            final Position arrivalPos = parsePlatform(pp);
+                            XmlPullUtil.skipExit(pp, "Arr");
+
+                            XmlPullUtil.skipExit(pp, "BasicStop");
+                            XmlPullUtil.skipExit(pp, "Arrival");
+
+                            // remove last intermediate
+                            if (intermediateStops != null)
+                                if (!intermediateStops.isEmpty())
+                                    if (!intermediateStops.get(intermediateStops.size() - 1).location
+                                            .equals(sectionArrivalLocation))
+                                        intermediateStops.remove(intermediateStops.size() - 1);
+
+                            XmlPullUtil.skipExit(pp, "ConSection");
+
+                            if (line != null) {
+                                final Stop departure = new Stop(sectionDepartureLocation, true, departureTime, null,
+                                        departurePos, null);
+                                final Stop arrival = new Stop(sectionArrivalLocation, false, arrivalTime, null,
+                                        arrivalPos, null);
+
+                                legs.add(new Trip.Public(line, destination, departure, arrival, intermediateStops, path,
+                                        null));
+                            } else {
+                                if (legs.size() > 0 && legs.get(legs.size() - 1) instanceof Trip.Individual) {
+                                    final Trip.Individual lastIndividualLeg = (Trip.Individual) legs
+                                            .remove(legs.size() - 1);
+                                    legs.add(new Trip.Individual(Trip.Individual.Type.WALK, lastIndividualLeg.departure,
+                                            lastIndividualLeg.departureTime, sectionArrivalLocation, arrivalTime, null,
+                                            0));
+                                } else {
+                                    legs.add(new Trip.Individual(Trip.Individual.Type.WALK, sectionDepartureLocation,
+                                            departureTime, sectionArrivalLocation, arrivalTime, null, 0));
+                                }
+                            }
+                        }
+
+                        XmlPullUtil.skipExit(pp, "ConSectionList");
+
+                        XmlPullUtil.skipExit(pp, "Connection");
+
+                        trips.add(new Trip(id, departureLocation, arrivalLocation, legs, null, capacity, numTransfers));
+                    }
+
+                    XmlPullUtil.skipExit(pp, "ConnectionList");
+
+                    result.set(new QueryTripsResult(header, null, from, via, to, context, trips));
+                } catch (final XmlPullParserException x) {
+                    throw new ParserException("cannot parse xml: " + bodyPeek, x);
+                }
+            }
+        }, endpoint, request, "application/xml", null);
+
+        return result.get();
+    }
+
+    private final Location parseLocation(final XmlPullParser pp) throws XmlPullParserException, IOException {
+        final Location location;
+        if (pp.getName().equals("Station"))
+            location = parseStation(pp);
+        else if (pp.getName().equals("Poi"))
+            location = parsePoi(pp);
+        else if (pp.getName().equals("Address"))
+            location = parseAddress(pp);
+        else
+            throw new IllegalStateException("cannot parse: " + pp.getName());
+        XmlPullUtil.next(pp);
+        return location;
+    }
+
+    private final Map<String, String> parseAttributeVariants(final XmlPullParser pp)
+            throws XmlPullParserException, IOException {
+        final Map<String, String> attributeVariants = new HashMap<String, String>();
+
+        while (XmlPullUtil.test(pp, "AttributeVariant")) {
+            final String type = XmlPullUtil.attr(pp, "type");
+            XmlPullUtil.enter(pp, "AttributeVariant");
+            final String value = XmlPullUtil.optValueTag(pp, "Text", null);
+            XmlPullUtil.skipExit(pp, "AttributeVariant");
+
+            attributeVariants.put(type, value);
+        }
+
+        return attributeVariants;
+    }
+
+    private static final Pattern P_DATE = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");
+
+    private static final void parseDate(final Calendar calendar, final CharSequence str) {
+        final Matcher m = P_DATE.matcher(str);
+        if (!m.matches())
+            throw new RuntimeException("cannot parse: '" + str + "'");
+
+        calendar.set(Calendar.YEAR, Integer.parseInt(m.group(1)));
+        calendar.set(Calendar.MONTH, Integer.parseInt(m.group(2)) - 1);
+        calendar.set(Calendar.DAY_OF_MONTH, Integer.parseInt(m.group(3)));
+    }
+
+    private static final Pattern P_TIME = Pattern.compile("(\\d+)d(\\d+):(\\d{2}):(\\d{2})");
+
+    private static void parseTime(final Calendar calendar, final CharSequence str) {
+        final Matcher m = P_TIME.matcher(str);
+        if (!m.matches())
+            throw new IllegalArgumentException("cannot parse: '" + str + "'");
+
+        calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(m.group(2)));
+        calendar.set(Calendar.MINUTE, Integer.parseInt(m.group(3)));
+        calendar.set(Calendar.SECOND, Integer.parseInt(m.group(4)));
+        calendar.set(Calendar.MILLISECOND, 0);
+        calendar.add(Calendar.DAY_OF_MONTH, Integer.parseInt(m.group(1)));
+    }
+
+    private static final String locationXml(final Location location) {
+        if (location.type == LocationType.STATION && location.hasId())
+            return "<Station externalId=\"" + normalizeStationId(location.id) + "\" />";
+        else if (location.type == LocationType.POI && location.hasLocation())
+            return "<Poi type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" />";
+        else if (location.type == LocationType.ADDRESS && location.hasLocation())
+            return "<Address type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" name=\""
+                    + (location.place != null ? location.place + ", " : "") + location.name + "\" />";
+        else if (location.type == LocationType.COORD && location.hasLocation())
+            return "<Coord type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" />";
+        else
+            throw new IllegalArgumentException("cannot handle: " + location);
+    }
+
+    protected final String locationId(final Location location) {
+        final StringBuilder id = new StringBuilder();
+
+        id.append("A=").append(locationType(location));
+
+        if (location.type == LocationType.STATION && location.hasId()) {
+            id.append("@L=").append(normalizeStationId(location.id));
+        } else if (location.hasLocation()) {
+            id.append("@X=").append(location.lon);
+            id.append("@Y=").append(location.lat);
+            id.append("@O=").append(location.name != null ? location.name
+                    : String.format(Locale.ENGLISH, "%.6f, %.6f", location.lat / 1E6, location.lon / 1E6));
+        } else if (location.name != null) {
+            id.append("@G=").append(location.name);
+            if (location.type != LocationType.ANY)
+                id.append('!');
+        }
+
+        return id.toString();
+    }
+
+    protected static final int locationType(final Location location) {
+        final LocationType type = location.type;
+        if (type == LocationType.STATION)
+            return 1;
+        if (type == LocationType.POI)
+            return 4;
+        if (type == LocationType.COORD || (type == LocationType.ADDRESS && location.hasLocation()))
+            return 16;
+        if (type == LocationType.ADDRESS && location.name != null)
+            return 2;
+        if (type == LocationType.ANY)
+            return 255;
+        throw new IllegalArgumentException(location.type.toString());
+    }
+
+    protected void appendQueryTripsBinaryParameters(final HttpUrl.Builder url, final Location from,
+            final @Nullable Location via, final Location to, final Date date, final boolean dep,
+            final @Nullable Set<Product> products, final @Nullable Accessibility accessibility,
+            final @Nullable Set<Option> options) {
+        url.addQueryParameter("start", "Suchen");
+        url.addEncodedQueryParameter("REQ0JourneyStopsS0ID",
+                ParserUtils.urlEncode(locationId(from), requestUrlEncoding));
+        url.addEncodedQueryParameter("REQ0JourneyStopsZ0ID", ParserUtils.urlEncode(locationId(to), requestUrlEncoding));
+
+        if (via != null) {
+            // workaround, for there does not seem to be a REQ0JourneyStops1.0ID parameter
+            url.addQueryParameter("REQ0JourneyStops1.0A", Integer.toString(locationType(via)));
+
+            if (via.type == LocationType.STATION && via.hasId()) {
+                url.addQueryParameter("REQ0JourneyStops1.0L", via.id);
+            } else if (via.hasLocation()) {
+                url.addQueryParameter("REQ0JourneyStops1.0X", Integer.toString(via.lon));
+                url.addQueryParameter("REQ0JourneyStops1.0Y", Integer.toString(via.lat));
+                if (via.name == null)
+                    url.addQueryParameter("REQ0JourneyStops1.0O",
+                            String.format(Locale.ENGLISH, "%.6f, %.6f", via.lat / 1E6, via.lon / 1E6));
+            } else if (via.name != null) {
+                url.addEncodedQueryParameter("REQ0JourneyStops1.0G", ParserUtils
+                        .urlEncode(via.name + (via.type != LocationType.ANY ? "!" : ""), requestUrlEncoding));
+            }
+        }
+
+        url.addQueryParameter("REQ0HafasSearchForw", dep ? "1" : "0");
+
+        appendDateTimeParameters(url, date, "REQ0JourneyDate", "REQ0JourneyTime");
+
+        final CharSequence productsStr;
+        if (products != null)
+            productsStr = productsString(products);
+        else
+            productsStr = allProductsString();
+        url.addQueryParameter("REQ0JourneyProduct_prod_list_1", productsStr.toString());
+
+        if (accessibility != null && accessibility != Accessibility.NEUTRAL) {
+            if (accessibility == Accessibility.LIMITED)
+                url.addQueryParameter("REQ0AddParamBaimprofile", "1");
+            else if (accessibility == Accessibility.BARRIER_FREE)
+                url.addQueryParameter("REQ0AddParamBaimprofile", "0");
+        }
+
+        if (options != null && options.contains(Option.BIKE))
+            url.addQueryParameter("REQ0JourneyProduct_opt3", "1");
+
+        appendCommonQueryTripsBinaryParameters(url);
+    }
+
+    protected void appendCommonQueryTripsBinaryParameters(final HttpUrl.Builder url) {
+        url.addQueryParameter("h2g-direct", "11");
+        if (clientType != null)
+            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
+    }
+
+    private final static int QUERY_TRIPS_BINARY_BUFFER_SIZE = 384 * 1024;
+
+    protected final QueryTripsResult queryTripsBinary(Location from, @Nullable Location via, Location to,
+            final Date date, final boolean dep, final @Nullable Set<Product> products,
+            final @Nullable WalkSpeed walkSpeed, final @Nullable Accessibility accessibility,
+            final @Nullable Set<Option> options) throws IOException {
+        final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+
+        if (!from.isIdentified()) {
+            final List<Location> locations = suggestLocations(from.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, locations, null, null);
+            from = locations.get(0);
+        }
+
+        if (via != null && !via.isIdentified()) {
+            final List<Location> locations = suggestLocations(via.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, null, locations, null);
+            via = locations.get(0);
+        }
+
+        if (!to.isIdentified()) {
+            final List<Location> locations = suggestLocations(to.name).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, null, null, locations);
+            to = locations.get(0);
+        }
+
+        final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage);
+        appendQueryTripsBinaryParameters(url, from, via, to, date, dep, products, accessibility, options);
+        return queryTripsBinary(url.build(), from, via, to, QUERY_TRIPS_BINARY_BUFFER_SIZE);
+    }
+
+    protected void appendQueryMoreTripsBinaryParameters(final HttpUrl.Builder url,
+            final QueryTripsBinaryContext context, final boolean later) {
+        url.addQueryParameter("seqnr", Integer.toString(context.seqNr));
+        url.addQueryParameter("ident", context.ident);
+        if (context.ld != null)
+            url.addQueryParameter("ld", context.ld);
+        url.addQueryParameter("REQ0HafasScrollDir", later ? "1" : "2");
+        appendCommonQueryTripsBinaryParameters(url);
+    }
+
+    protected QueryTripsResult queryMoreTripsBinary(final QueryTripsContext contextObj, final boolean later)
+            throws IOException {
+        final QueryTripsBinaryContext context = (QueryTripsBinaryContext) contextObj;
+
+        final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage);
+        appendQueryMoreTripsBinaryParameters(url, context, later);
+        return queryTripsBinary(url.build(), null, null, null, QUERY_TRIPS_BINARY_BUFFER_SIZE + context.usedBufferSize);
+    }
+
+    private class CustomBufferedInputStream extends BufferedInputStream {
+        public CustomBufferedInputStream(final InputStream in) {
+            super(in);
+        }
+
+        public int getCount() {
+            return count;
+        }
+    }
+
+    private QueryTripsResult queryTripsBinary(final HttpUrl url, final Location from, final @Nullable Location via,
+            final Location to, final int expectedBufferSize) throws IOException {
+        /*
+         * Many thanks to Malte Starostik and Robert, who helped a lot with analyzing this API!
+         */
+
+        final AtomicReference<QueryTripsResult> result = new AtomicReference<QueryTripsResult>();
+
+        httpClient.getInputStream(new HttpClient.Callback() {
+            @Override
+            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
+                final CustomBufferedInputStream bis = new CustomBufferedInputStream(
+                        new GZIPInputStream(body.byteStream()));
+
+                // initialize input stream
+                final LittleEndianDataInputStream is = new LittleEndianDataInputStream(bis);
+                is.mark(expectedBufferSize);
+
+                // quick check of status
+                final int version = is.readShortReverse();
+                if (version != 6 && version != 5)
+                    throw new IllegalStateException("unknown version: " + version + ", first chars: " + bodyPeek);
+                final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, Integer.toString(version), null,
+                        0, null);
+
+                // quick seek for pointers
+                is.reset();
+                is.skipBytes(0x20);
+                final int serviceDaysTablePtr = is.readIntReverse();
+                final int stringTablePtr = is.readIntReverse();
+
+                is.reset();
+                is.skipBytes(0x36);
+                final int stationTablePtr = is.readIntReverse();
+                final int commentTablePtr = is.readIntReverse();
+
+                is.reset();
+                is.skipBytes(0x46);
+                final int extensionHeaderPtr = is.readIntReverse();
+
+                // read strings
+                final StringTable strings = new StringTable(is, stringTablePtr, serviceDaysTablePtr - stringTablePtr);
+
+                is.reset();
+                is.skipBytes(extensionHeaderPtr);
+
+                // read extension header
+                final int extensionHeaderLength = is.readIntReverse();
+                if (extensionHeaderLength < 0x2c)
+                    throw new IllegalStateException("too short: " + extensionHeaderLength);
+
+                is.skipBytes(12);
+                final int errorCode = is.readShortReverse();
+
+                if (errorCode == 0) {
+                    // string encoding
+                    is.skipBytes(14);
+                    final Charset stringEncoding = Charset.forName(strings.read(is));
+                    strings.setEncoding(stringEncoding);
+
+                    // read number of trips
+                    is.reset();
+                    is.skipBytes(30);
+
+                    final int numTrips = is.readShortReverse();
+                    if (numTrips == 0) {
+                        result.set(new QueryTripsResult(header, url.toString(), from, via, to, null,
+                                new LinkedList<Trip>()));
+                        return;
+                    }
+
+                    // read rest of header
+                    is.reset();
+                    is.skipBytes(0x02);
+
+                    final Location resDeparture = location(is, strings);
+                    final Location resArrival = location(is, strings);
+
+                    is.skipBytes(10);
+
+                    final long resDate = date(is);
+                    /* final long resDate30 = */date(is);
+
+                    is.reset();
+                    is.skipBytes(extensionHeaderPtr + 0x8);
+
+                    final int seqNr = is.readShortReverse();
+                    if (seqNr == 0)
+                        throw new SessionExpiredException();
+                    else if (seqNr < 0)
+                        throw new IllegalStateException("illegal sequence number: " + seqNr);
+
+                    final String requestId = strings.read(is);
+
+                    final int tripDetailsPtr = is.readIntReverse();
+                    if (tripDetailsPtr == 0)
+                        throw new IllegalStateException("no connection details");
+
+                    is.skipBytes(4);
+
+                    final int disruptionsPtr = is.readIntReverse();
+
+                    is.skipBytes(10);
+
+                    final String ld = strings.read(is);
+                    final int attrsOffset = is.readIntReverse();
+
+                    final int tripAttrsPtr;
+                    if (extensionHeaderLength >= 0x30) {
+                        if (extensionHeaderLength < 0x32)
+                            throw new IllegalArgumentException("too short: " + extensionHeaderLength);
+                        is.reset();
+                        is.skipBytes(extensionHeaderPtr + 0x2c);
+                        tripAttrsPtr = is.readIntReverse();
+                    } else {
+                        tripAttrsPtr = 0;
+                    }
+
+                    // determine stops offset
+                    is.reset();
+                    is.skipBytes(tripDetailsPtr);
+                    final int tripDetailsVersion = is.readShortReverse();
+                    if (tripDetailsVersion != 1)
+                        throw new IllegalStateException("unknown trip details version: " + tripDetailsVersion);
+                    is.skipBytes(0x02);
+
+                    final int tripDetailsIndexOffset = is.readShortReverse();
+                    final int tripDetailsLegOffset = is.readShortReverse();
+                    final int tripDetailsLegSize = is.readShortReverse();
+                    final int stopsSize = is.readShortReverse();
+                    final int stopsOffset = is.readShortReverse();
+
+                    // read stations
+                    final StationTable stations = new StationTable(is, stationTablePtr,
+                            commentTablePtr - stationTablePtr, strings);
+
+                    // read comments
+                    final CommentTable comments = new CommentTable(is, commentTablePtr,
+                            tripDetailsPtr - commentTablePtr, strings);
+
+                    final List<Trip> trips = new ArrayList<Trip>(numTrips);
+
+                    // read trips
+                    for (int iTrip = 0; iTrip < numTrips; iTrip++) {
+                        is.reset();
+                        is.skipBytes(0x4a + iTrip * 12);
+
+                        final int serviceDaysTableOffset = is.readShortReverse();
+
+                        final int legsOffset = is.readIntReverse();
+
+                        final int numLegs = is.readShortReverse();
+
+                        final int numChanges = is.readShortReverse();
+
+                        /* final long duration = time(is, 0, 0); */is.readShortReverse();
+
+                        is.reset();
+                        is.skipBytes(serviceDaysTablePtr + serviceDaysTableOffset);
+
+                        /* final String serviceDaysText = */strings.read(is);
+
+                        final int serviceBitBase = is.readShortReverse();
+                        final int serviceBitLength = is.readShortReverse();
+
+                        int tripDayOffset = serviceBitBase * 8;
+                        for (int i = 0; i < serviceBitLength; i++) {
+                            int serviceBits = is.read();
+                            if (serviceBits == 0) {
+                                tripDayOffset += 8;
+                                continue;
+                            }
+                            while ((serviceBits & 0x80) == 0) {
+                                serviceBits = serviceBits << 1;
+                                tripDayOffset++;
+                            }
+                            break;
+                        }
+
+                        is.reset();
+                        is.skipBytes(tripDetailsPtr + tripDetailsIndexOffset + iTrip * 2);
+                        final int tripDetailsOffset = is.readShortReverse();
+
+                        is.reset();
+                        is.skipBytes(tripDetailsPtr + tripDetailsOffset);
+                        final int realtimeStatus = is.readShortReverse();
+
+                        /* final short delay = */is.readShortReverse();
+
+                        /* final int legIndex = */is.readShortReverse();
+
+                        is.skipBytes(2); // 0xffff
+
+                        /* final int legStatus = */is.readShortReverse();
+
+                        is.skipBytes(2); // 0x0000
+
+                        String connectionId = null;
+                        if (tripAttrsPtr != 0) {
+                            is.reset();
+                            is.skipBytes(tripAttrsPtr + iTrip * 2);
+                            final int tripAttrsIndex = is.readShortReverse();
+
+                            is.reset();
+                            is.skipBytes(attrsOffset + tripAttrsIndex * 4);
+                            while (true) {
+                                final String key = strings.read(is);
+                                if (key == null)
+                                    break;
+                                else if (key.equals("ConnectionId"))
+                                    connectionId = strings.read(is);
+                                else
+                                    is.skipBytes(2);
+                            }
+                        }
+
+                        final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(numLegs);
+
+                        for (int iLegs = 0; iLegs < numLegs; iLegs++) {
+                            is.reset();
+                            is.skipBytes(0x4a + legsOffset + iLegs * 20);
+
+                            final long plannedDepartureTime = time(is, resDate, tripDayOffset);
+                            final Location departureLocation = stations.read(is);
+
+                            final long plannedArrivalTime = time(is, resDate, tripDayOffset);
+                            final Location arrivalLocation = stations.read(is);
+
+                            final int type = is.readShortReverse();
+
+                            final String lineName = strings.read(is);
+
+                            final Position plannedDeparturePosition = normalizePosition(strings.read(is));
+                            final Position plannedArrivalPosition = normalizePosition(strings.read(is));
+
+                            final int legAttrIndex = is.readShortReverse();
+
+                            final List<Line.Attr> lineAttrs = new ArrayList<Line.Attr>();
+                            String lineComment = null;
+                            boolean lineOnDemand = false;
+                            for (final String comment : comments.read(is)) {
+                                if (comment.startsWith("bf ")) {
+                                    lineAttrs.add(Line.Attr.WHEEL_CHAIR_ACCESS);
+                                } else if (comment.startsWith("FA ") || comment.startsWith("FB ")
+                                        || comment.startsWith("FR ")) {
+                                    lineAttrs.add(Line.Attr.BICYCLE_CARRIAGE);
+                                } else if (comment.startsWith("$R ") || comment.startsWith("ga ")
+                                        || comment.startsWith("ja ") || comment.startsWith("Vs ")
+                                        || comment.startsWith("mu ") || comment.startsWith("mx ")) {
+                                    lineOnDemand = true;
+                                    lineComment = comment.substring(5);
+                                }
+                            }
+
+                            is.reset();
+                            is.skipBytes(attrsOffset + legAttrIndex * 4);
+                            String directionStr = null;
+                            int lineClass = 0;
+                            String lineCategory = null;
+                            String routingType = null;
+                            String lineNetwork = null;
+                            while (true) {
+                                final String key = strings.read(is);
+                                if (key == null)
+                                    break;
+                                else if (key.equals("Direction"))
+                                    directionStr = strings.read(is);
+                                else if (key.equals("Class"))
+                                    lineClass = Integer.parseInt(strings.read(is));
+                                else if (key.equals("Category"))
+                                    lineCategory = strings.read(is);
+                                // else if (key.equals("Operator"))
+                                // lineOperator = strings.read(is);
+                                else if (key.equals("GisRoutingType"))
+                                    routingType = strings.read(is);
+                                else if (key.equals("AdminCode"))
+                                    lineNetwork = normalizeLineAdministration(strings.read(is));
+                                else
+                                    is.skipBytes(2);
+                            }
+
+                            if (lineCategory == null && lineName != null)
+                                lineCategory = categoryFromName(lineName);
+
+                            is.reset();
+                            is.skipBytes(tripDetailsPtr + tripDetailsOffset + tripDetailsLegOffset
+                                    + iLegs * tripDetailsLegSize);
+
+                            if (tripDetailsLegSize != 16)
+                                throw new IllegalStateException(
+                                        "unhandled trip details leg size: " + tripDetailsLegSize);
+
+                            final long predictedDepartureTime = time(is, resDate, tripDayOffset);
+                            final long predictedArrivalTime = time(is, resDate, tripDayOffset);
+                            final Position predictedDeparturePosition = normalizePosition(strings.read(is));
+                            final Position predictedArrivalPosition = normalizePosition(strings.read(is));
+
+                            final int bits = is.readShortReverse();
+                            final boolean arrivalCancelled = (bits & 0x10) != 0;
+                            final boolean departureCancelled = (bits & 0x20) != 0;
+
+                            is.readShort();
+
+                            final int firstStopIndex = is.readShortReverse();
+
+                            final int numStops = is.readShortReverse();
+
+                            is.reset();
+                            is.skipBytes(disruptionsPtr);
+
+                            String disruptionText = null;
+
+                            if (is.readShortReverse() == 1) {
+                                is.reset();
+                                is.skipBytes(disruptionsPtr + 2 + iTrip * 2);
+
+                                int disruptionsOffset = is.readShortReverse();
+                                while (disruptionsOffset != 0) {
+                                    is.reset();
+                                    is.skipBytes(disruptionsPtr + disruptionsOffset);
+
+                                    strings.read(is); // "0"
+
+                                    final int disruptionLeg = is.readShortReverse();
+
+                                    is.skipBytes(2); // bitmaske
+
+                                    strings.read(is); // start of line
+                                    strings.read(is); // end of line
+
+                                    strings.read(is);
+                                    // id
+                                    /* final String disruptionTitle = */strings.read(is);
+                                    final String disruptionShortText = ParserUtils.formatHtml(strings.read(is));
+
+                                    disruptionsOffset = is.readShortReverse(); // next
+
+                                    if (iLegs == disruptionLeg) {
+                                        final int disruptionAttrsIndex = is.readShortReverse();
+
+                                        is.reset();
+                                        is.skipBytes(attrsOffset + disruptionAttrsIndex * 4);
+
+                                        while (true) {
+                                            final String key = strings.read(is);
+                                            if (key == null)
+                                                break;
+                                            else if (key.equals("Text"))
+                                                disruptionText = ParserUtils.resolveEntities(strings.read(is));
+                                            else
+                                                is.skipBytes(2);
+                                        }
+
+                                        if (disruptionShortText != null)
+                                            disruptionText = disruptionShortText;
+                                    }
+                                }
+                            }
+
+                            List<Stop> intermediateStops = null;
+
+                            if (numStops > 0) {
+                                is.reset();
+                                is.skipBytes(tripDetailsPtr + stopsOffset + firstStopIndex * stopsSize);
+
+                                if (stopsSize != 26)
+                                    throw new IllegalStateException("unhandled stops size: " + stopsSize);
+
+                                intermediateStops = new ArrayList<Stop>(numStops);
+
+                                for (int iStop = 0; iStop < numStops; iStop++) {
+                                    final long plannedStopDepartureTime = time(is, resDate, tripDayOffset);
+                                    final Date plannedStopDepartureDate = plannedStopDepartureTime != 0
+                                            ? new Date(plannedStopDepartureTime) : null;
+                                    final long plannedStopArrivalTime = time(is, resDate, tripDayOffset);
+                                    final Date plannedStopArrivalDate = plannedStopArrivalTime != 0
+                                            ? new Date(plannedStopArrivalTime) : null;
+                                    final Position plannedStopDeparturePosition = normalizePosition(strings.read(is));
+                                    final Position plannedStopArrivalPosition = normalizePosition(strings.read(is));
+
+                                    is.readInt();
+
+                                    final long predictedStopDepartureTime = time(is, resDate, tripDayOffset);
+                                    final Date predictedStopDepartureDate = predictedStopDepartureTime != 0
+                                            ? new Date(predictedStopDepartureTime) : null;
+                                    final long predictedStopArrivalTime = time(is, resDate, tripDayOffset);
+                                    final Date predictedStopArrivalDate = predictedStopArrivalTime != 0
+                                            ? new Date(predictedStopArrivalTime) : null;
+                                    final Position predictedStopDeparturePosition = normalizePosition(strings.read(is));
+                                    final Position predictedStopArrivalPosition = normalizePosition(strings.read(is));
+
+                                    final int stopBits = is.readShortReverse();
+                                    final boolean stopArrivalCancelled = (stopBits & 0x10) != 0;
+                                    final boolean stopDepartureCancelled = (stopBits & 0x20) != 0;
+
+                                    is.readShort();
+
+                                    final Location stopLocation = stations.read(is);
+
+                                    final boolean validPredictedDate = !dominantPlanStopTime
+                                            || (plannedStopArrivalDate != null && plannedStopDepartureDate != null);
+
+                                    final Stop stop = new Stop(stopLocation, plannedStopArrivalDate,
+                                            validPredictedDate ? predictedStopArrivalDate : null,
+                                            plannedStopArrivalPosition, predictedStopArrivalPosition,
+                                            stopArrivalCancelled, plannedStopDepartureDate,
+                                            validPredictedDate ? predictedStopDepartureDate : null,
+                                            plannedStopDeparturePosition, predictedStopDeparturePosition,
+                                            stopDepartureCancelled);
+
+                                    intermediateStops.add(stop);
+                                }
+                            }
+
+                            final Trip.Leg leg;
+                            if (type == 1 /* Fussweg */ || type == 3 /* Uebergang */ || type == 4 /* Uebergang */) {
+                                final Trip.Individual.Type individualType;
+                                if (routingType == null)
+                                    individualType = type == 1 ? Trip.Individual.Type.WALK
+                                            : Trip.Individual.Type.TRANSFER;
+                                else if ("FOOT".equals(routingType))
+                                    individualType = Trip.Individual.Type.WALK;
+                                else if ("BIKE".equals(routingType))
+                                    individualType = Trip.Individual.Type.BIKE;
+                                else if ("CAR".equals(routingType) || "P+R".equals(routingType))
+                                    individualType = Trip.Individual.Type.CAR;
+                                else
+                                    throw new IllegalStateException("unknown routingType: " + routingType);
+
+                                final Date departureTime = new Date(
+                                        predictedDepartureTime != 0 ? predictedDepartureTime : plannedDepartureTime);
+                                final Date arrivalTime = new Date(
+                                        predictedArrivalTime != 0 ? predictedArrivalTime : plannedArrivalTime);
+
+                                final Trip.Leg lastLeg = legs.size() > 0 ? legs.get(legs.size() - 1) : null;
+                                if (lastLeg != null && lastLeg instanceof Trip.Individual
+                                        && ((Trip.Individual) lastLeg).type == individualType) {
+                                    final Trip.Individual lastIndividualLeg = (Trip.Individual) legs
+                                            .remove(legs.size() - 1);
+                                    leg = new Trip.Individual(individualType, lastIndividualLeg.departure,
+                                            lastIndividualLeg.departureTime, arrivalLocation, arrivalTime, null, 0);
+                                } else {
+                                    leg = new Trip.Individual(individualType, departureLocation, departureTime,
+                                            arrivalLocation, arrivalTime, null, 0);
+                                }
+                            } else if (type == 2) {
+                                final Product lineProduct;
+                                if (lineOnDemand)
+                                    lineProduct = Product.ON_DEMAND;
+                                else if (lineClass != 0)
+                                    lineProduct = intToProduct(lineClass);
+                                else
+                                    lineProduct = normalizeType(lineCategory);
+
+                                final Line line = newLine(lineNetwork, lineProduct, normalizeLineName(lineName),
+                                        lineComment, lineAttrs.toArray(new Line.Attr[0]));
+
+                                final Location direction;
+                                if (directionStr != null) {
+                                    final String[] directionPlaceAndName = splitStationName(directionStr);
+                                    direction = new Location(LocationType.ANY, null, directionPlaceAndName[0],
+                                            directionPlaceAndName[1]);
+                                } else {
+                                    direction = null;
+                                }
+
+                                final Stop departure = new Stop(departureLocation, true,
+                                        plannedDepartureTime != 0 ? new Date(plannedDepartureTime) : null,
+                                        predictedDepartureTime != 0 ? new Date(predictedDepartureTime) : null,
+                                        plannedDeparturePosition, predictedDeparturePosition, departureCancelled);
+                                final Stop arrival = new Stop(arrivalLocation, false,
+                                        plannedArrivalTime != 0 ? new Date(plannedArrivalTime) : null,
+                                        predictedArrivalTime != 0 ? new Date(predictedArrivalTime) : null,
+                                        plannedArrivalPosition, predictedArrivalPosition, arrivalCancelled);
+
+                                leg = new Trip.Public(line, direction, departure, arrival, intermediateStops, null,
+                                        disruptionText);
+                            } else {
+                                throw new IllegalStateException("unhandled type: " + type);
+                            }
+                            legs.add(leg);
+                        }
+
+                        final Trip trip = new Trip(connectionId, resDeparture, resArrival, legs, null, null,
+                                (int) numChanges);
+
+                        if (realtimeStatus != 2) // Verbindung fällt aus
+                            trips.add(trip);
+                    }
+
+                    // if result is only one single individual leg, don't query for more
+                    final boolean canQueryMore = trips.size() != 1 || trips.get(0).legs.size() != 1
+                            || !(trips.get(0).legs.get(0) instanceof Trip.Individual);
+
+                    result.set(new QueryTripsResult(header, url.toString(), from, via, to,
+                            new QueryTripsBinaryContext(requestId, seqNr, ld, bis.getCount(), canQueryMore), trips));
+                } else {
+                    log.debug("Hafas error: {}", errorCode);
+                    if (errorCode == 1) {
+                        throw new SessionExpiredException();
+                    } else if (errorCode == 2) {
+                        // F2: Your search results could not be stored internally.
+                        throw new SessionExpiredException();
+                    } else if (errorCode == 8) {
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.AMBIGUOUS));
+                        return;
+                    } else if (errorCode == 13) {
+                        // IN13: Our booking system is currently being used by too many users at the same
+                        // time.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                        return;
+                    } else if (errorCode == 19) {
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                        return;
+                    } else if (errorCode == 207) {
+                        // H207: Unfortunately your connection request can currently not be processed.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                        return;
+                    } else if (errorCode == 887) {
+                        // H887: Your inquiry was too complex. Please try entering less intermediate stations.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 890) {
+                        // H890: No connections have been found that correspond to your request. It is
+                        // possible
+                        // that the requested service does not operate from or to the places you stated on the
+                        // requested date of travel.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 891) {
+                        // H891: Unfortunately there was no route found. Missing timetable data could be the
+                        // reason.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 892) {
+                        // H892: Your inquiry was too complex. Please try entering less intermediate stations.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 899) {
+                        // H899: there was an unsuccessful or incomplete search due to a timetable change.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 900) {
+                        // Unsuccessful or incomplete search (timetable change)
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 9220) {
+                        // H9220: Nearby to the given address stations could not be found.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS));
+                        return;
+                    } else if (errorCode == 9240) {
+                        // H9240: Unfortunately there was no route found. Perhaps your start or destination is
+                        // not
+                        // served at all or with the selected means of transport on the required date/time.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
+                        return;
+                    } else if (errorCode == 9260) {
+                        // H9260: Unknown departure station
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM));
+                        return;
+                    } else if (errorCode == 9280) {
+                        // H9280: Unknown intermediate station
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA));
+                        return;
+                    } else if (errorCode == 9300) {
+                        // H9300: Unknown arrival station
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO));
+                        return;
+                    } else if (errorCode == 9320) {
+                        // The input is incorrect or incomplete
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
+                        return;
+                    } else if (errorCode == 9360) {
+                        // H9360: Unfortunately your connection request can currently not be processed.
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
+                        return;
+                    } else if (errorCode == 9380) {
+                        // H9380: Dep./Arr./Intermed. or equivalent station defined more than once
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
+                        return;
+                    } else if (errorCode == 895) {
+                        // H895: Departure/Arrival are too near
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
+                        return;
+                    } else if (errorCode == 65535) {
+                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
+                        return;
+                    } else {
+                        throw new IllegalStateException("error " + errorCode + " on " + url);
+                    }
+                }
+            }
+        }, url);
+
+        return result.get();
+    }
+
+    private Location location(final LittleEndianDataInputStream is, final StringTable strings) throws IOException {
+        final String name = strings.read(is);
+        is.readShort();
+        final int type = is.readShortReverse();
+        final int lon = is.readIntReverse();
+        final int lat = is.readIntReverse();
+
+        if (type == 1) {
+            final String[] placeAndName = splitStationName(name);
+            return new Location(LocationType.STATION, null, lat, lon, placeAndName[0], placeAndName[1]);
+        } else if (type == 2) {
+            final String[] placeAndName = splitAddress(name);
+            return new Location(LocationType.ADDRESS, null, lat, lon, placeAndName[0], placeAndName[1]);
+        } else if (type == 3) {
+            final String[] placeAndName = splitPOI(name);
+            return new Location(LocationType.POI, null, lat, lon, placeAndName[0], placeAndName[1]);
+        } else {
+            throw new IllegalStateException("unknown type: " + type + "  " + name);
+        }
+    }
+
+    private long date(final LittleEndianDataInputStream is) throws IOException {
+        final int days = is.readShortReverse();
+
+        final Calendar date = new GregorianCalendar(timeZone);
+        date.clear();
+        date.set(Calendar.YEAR, 1980);
+        date.set(Calendar.DAY_OF_YEAR, days);
+
+        return date.getTimeInMillis();
+    }
+
+    private long time(final LittleEndianDataInputStream is, final long baseDate, final int dayOffset)
+            throws IOException {
+        final int value = is.readShortReverse();
+        if (value == 0xffff)
+            return 0;
+
+        final int hours = value / 100;
+        final int minutes = value % 100;
+
+        if (minutes < 0 || minutes > 60)
+            throw new IllegalStateException("minutes out of range: " + minutes);
+
+        final Calendar time = new GregorianCalendar(timeZone);
+
+        time.setTimeInMillis(baseDate);
+        if (time.get(Calendar.HOUR) != 0 || time.get(Calendar.MINUTE) != 0)
+            throw new IllegalStateException("baseDate not on date boundary: " + baseDate);
+
+        time.add(Calendar.DAY_OF_YEAR, dayOffset);
+
+        time.set(Calendar.HOUR, hours);
+        time.set(Calendar.MINUTE, minutes);
+
+        return time.getTimeInMillis();
+    }
+
+    private static class StringTable {
+        private Charset encoding = Charsets.US_ASCII;
+        private final byte[] table;
+
+        public StringTable(final DataInputStream is, final int stringTablePtr, final int length) throws IOException {
+            is.reset();
+            is.skipBytes(stringTablePtr);
+            table = new byte[length];
+            is.readFully(table);
+        }
+
+        public void setEncoding(final Charset encoding) {
+            this.encoding = encoding;
+        }
+
+        public String read(final LittleEndianDataInputStream is) throws IOException {
+            final int pointer = is.readShortReverse();
+            if (pointer == 0)
+                return null;
+            if (pointer >= table.length)
+                throw new IllegalStateException(
+                        "pointer " + pointer + " cannot exceed strings table size " + table.length);
+
+            final InputStreamReader reader = new InputStreamReader(
+                    new ByteArrayInputStream(table, pointer, table.length - pointer), encoding);
+
+            try {
+                final StringBuilder builder = new StringBuilder();
+
+                int c;
+                while ((c = reader.read()) != 0)
+                    builder.append((char) c);
+
+                return builder.toString().trim();
+            } finally {
+                reader.close();
+            }
+        }
+    }
+
+    private static class CommentTable {
+        private final StringTable strings;
+        private final byte[] table;
+
+        public CommentTable(final DataInputStream is, final int commentTablePtr, final int length,
+                final StringTable strings) throws IOException {
+            is.reset();
+            is.skipBytes(commentTablePtr);
+            table = new byte[length];
+            is.readFully(table);
+
+            this.strings = strings;
+        }
+
+        public String[] read(final LittleEndianDataInputStream is) throws IOException {
+            final int pointer = is.readShortReverse();
+            if (pointer >= table.length)
+                throw new IllegalStateException(
+                        "pointer " + pointer + " cannot exceed comments table size " + table.length);
+
+            final LittleEndianDataInputStream commentsInputStream = new LittleEndianDataInputStream(
+                    new ByteArrayInputStream(table, pointer, table.length - pointer));
+
+            try {
+                final int numComments = commentsInputStream.readShortReverse();
+                final String[] comments = new String[numComments];
+
+                for (int i = 0; i < numComments; i++)
+                    comments[i] = strings.read(commentsInputStream);
+
+                return comments;
+            } finally {
+                commentsInputStream.close();
+            }
+        }
+    }
+
+    private class StationTable {
+        private final StringTable strings;
+        private final byte[] table;
+
+        public StationTable(final DataInputStream is, final int stationTablePtr, final int length,
+                final StringTable strings) throws IOException {
+            is.reset();
+            is.skipBytes(stationTablePtr);
+            table = new byte[length];
+            is.readFully(table);
+
+            this.strings = strings;
+        }
+
+        private Location read(final LittleEndianDataInputStream is) throws IOException {
+            final int index = is.readShortReverse();
+            final int ptr = index * 14;
+            if (ptr >= table.length)
+                throw new IllegalStateException(
+                        "pointer " + ptr + " cannot exceed stations table size " + table.length);
+
+            final LittleEndianDataInputStream stationInputStream = new LittleEndianDataInputStream(
+                    new ByteArrayInputStream(table, ptr, 14));
+
+            try {
+                final String[] placeAndName = splitStationName(strings.read(stationInputStream));
+                final int id = stationInputStream.readIntReverse();
+                final int lon = stationInputStream.readIntReverse();
+                final int lat = stationInputStream.readIntReverse();
+
+                return new Location(LocationType.STATION, id != 0 ? Integer.toString(id) : null, lat, lon,
+                        placeAndName[0], placeAndName[1]);
+            } finally {
+                stationInputStream.close();
+            }
+        }
+    }
+
+    @Override
+    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
+            final int maxDistance, final int maxLocations) throws IOException {
+        if (location.hasLocation())
+            return nearbyLocationsByCoordinate(types, location.lat, location.lon, maxDistance, maxLocations);
+        else if (location.type == LocationType.STATION && location.hasId())
+            return nearbyStationsById(location.id, maxDistance);
+        else
+            throw new IllegalArgumentException("cannot handle: " + location);
+    }
+
+    protected final NearbyLocationsResult nearbyLocationsByCoordinate(final EnumSet<LocationType> types, final int lat,
+            final int lon, final int maxDistance, final int maxLocations) throws IOException {
+        if (types.contains(LocationType.STATION)) {
+            final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage + "y");
+            appendJsonNearbyStationsParameters(url, lat, lon, maxDistance, maxLocations);
+            return jsonNearbyLocations(url.build());
+        } else if (types.contains(LocationType.POI)) {
+            final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage + "y");
+            appendJsonNearbyPOIsParameters(url, lat, lon, maxDistance, maxLocations);
+            return jsonNearbyLocations(url.build());
+        } else {
+            return new NearbyLocationsResult(null, Collections.<Location> emptyList());
+        }
+    }
+
+    protected NearbyLocationsResult nearbyStationsById(final String id, final int maxDistance) throws IOException {
+        final HttpUrl.Builder url = stationBoardEndpoint.newBuilder().addPathSegment(apiLanguage);
+        appendXmlNearbyStationsParameters(url, id);
+        return xmlNearbyStations(url.build());
+    }
+
+    protected final void appendXmlNearbyStationsParameters(final HttpUrl.Builder url, final String stationId) {
+        url.addQueryParameter("productsFilter", allProductsString().toString());
+        url.addQueryParameter("boardType", "dep");
+        url.addEncodedQueryParameter("input", ParserUtils.urlEncode(normalizeStationId(stationId), requestUrlEncoding));
+        url.addQueryParameter("sTI", "1");
+        url.addQueryParameter("start", "yes");
+        url.addQueryParameter("hcount", "0");
+        url.addQueryParameter("L", "vs_java3");
+        if (clientType != null)
+            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
+    }
+
+    private static final Pattern P_XML_NEARBY_STATIONS_COARSE = Pattern.compile("\\G<\\s*St\\s*(.*?)/?>(?:\n|\\z)",
+            Pattern.DOTALL);
+    private static final Pattern P_XML_NEARBY_STATIONS_FINE = Pattern.compile(
+            "" //
+                    + "evaId=\"(\\d+)\"\\s*" // id
+                    + "name=\"([^\"]+)\".*?" // name
+                    + "(?:x=\"(\\d+)\"\\s*)?" // x
+                    + "(?:y=\"(\\d+)\"\\s*)?" // y
+            , Pattern.DOTALL);
+    private static final Pattern P_XML_NEARBY_STATIONS_MESSAGES = Pattern
+            .compile("<Err code=\"([^\"]*)\" text=\"([^\"]*)\"");
+
+    protected final NearbyLocationsResult xmlNearbyStations(final HttpUrl url) throws IOException {
+        // scrape page
+        final CharSequence page = httpClient.get(url);
+
+        final List<Location> stations = new ArrayList<Location>();
+
+        // parse page
+        final Matcher mMessage = P_XML_NEARBY_STATIONS_MESSAGES.matcher(page);
+        if (mMessage.find()) {
+            final String code = mMessage.group(1);
+            final String text = mMessage.group(2);
+
+            if (code.equals("H730")) // Your input is not valid
+                return new NearbyLocationsResult(null, NearbyLocationsResult.Status.INVALID_ID);
+            if (code.equals("H890")) // No trains in result
+                return new NearbyLocationsResult(null, stations);
+            throw new IllegalArgumentException("unknown error " + code + ", " + text);
+        }
+
+        final Matcher mCoarse = P_XML_NEARBY_STATIONS_COARSE.matcher(page);
+        while (mCoarse.find()) {
+            final Matcher mFine = P_XML_NEARBY_STATIONS_FINE.matcher(mCoarse.group(1));
+            if (mFine.matches()) {
+                final String parsedId = mFine.group(1);
+
+                final String parsedName = ParserUtils.resolveEntities(mFine.group(2)).trim();
+
+                final int parsedLon;
+                final int parsedLat;
+                if (mFine.group(3) != null && mFine.group(4) != null) {
+                    parsedLon = Integer.parseInt(mFine.group(3));
+                    parsedLat = Integer.parseInt(mFine.group(4));
+                } else {
+                    parsedLon = 0;
+                    parsedLat = 0;
+                }
+
+                final String[] placeAndName = splitStationName(parsedName);
+                stations.add(new Location(LocationType.STATION, parsedId, parsedLat, parsedLon, placeAndName[0],
+                        placeAndName[1]));
+            } else {
+                throw new IllegalArgumentException("cannot parse '" + mCoarse.group(1) + "' on " + url);
+            }
+        }
+
+        return new NearbyLocationsResult(null, stations);
+    }
+
+    protected void appendJsonNearbyStationsParameters(final HttpUrl.Builder url, final int lat, final int lon,
+            final int maxDistance, final int maxStations) {
+        url.addQueryParameter("performLocating", "2");
+        url.addQueryParameter("tpl", "stop2json");
+        url.addQueryParameter("look_stopclass", Integer.toString(allProductsInt()));
+        url.addQueryParameter("look_nv", "get_stopweight|yes");
+        // get_shortjson|yes
+        // get_lines|yes
+        // combinemode|2
+        // density|80
+        // get_stopweight|yes
+        // get_infotext|yes
+        url.addQueryParameter("look_x", Integer.toString(lon));
+        url.addQueryParameter("look_y", Integer.toString(lat));
+        url.addQueryParameter("look_maxno", Integer.toString(maxStations != 0 ? maxStations : 200));
+        url.addQueryParameter("look_maxdist", Integer.toString(maxDistance != 0 ? maxDistance : 5000));
+    }
+
+    protected void appendJsonNearbyPOIsParameters(final HttpUrl.Builder url, final int lat, final int lon,
+            final int maxDistance, final int maxStations) {
+        url.addQueryParameter("performLocating", "4");
+        url.addQueryParameter("tpl", "poi2json");
+        url.addQueryParameter("look_pois", ""); // all categories
+        url.addQueryParameter("look_x", Integer.toString(lon));
+        url.addQueryParameter("look_y", Integer.toString(lat));
+        url.addQueryParameter("look_maxno", Integer.toString(maxStations != 0 ? maxStations : 200));
+        url.addQueryParameter("look_maxdist", Integer.toString(maxDistance != 0 ? maxDistance : 5000));
+    }
+
+    protected final NearbyLocationsResult jsonNearbyLocations(final HttpUrl url) throws IOException {
+        final CharSequence page = httpClient.get(url);
+
+        try {
+            final JSONObject head = new JSONObject(page.toString());
+            final int error = head.getInt("error");
+            if (error == 0) {
+                final List<Location> locations = new LinkedList<Location>();
+
+                final JSONArray aStops = head.optJSONArray("stops");
+                if (aStops != null) {
+                    final int nStops = aStops.length();
+
+                    for (int i = 0; i < nStops; i++) {
+                        final JSONObject stop = aStops.optJSONObject(i);
+                        final String id = stop.getString("extId");
+                        // final String name = ParserUtils.resolveEntities(stop.getString("name"));
+                        final String urlname = ParserUtils.urlDecode(stop.getString("urlname"),
+                                jsonNearbyLocationsEncoding);
+                        final int lat = stop.getInt("y");
+                        final int lon = stop.getInt("x");
+                        final int prodclass = stop.optInt("prodclass", -1);
+                        final int stopWeight = stop.optInt("stopweight", -1);
+
+                        if (stopWeight != 0) {
+                            final String[] placeAndName = splitStationName(urlname);
+                            final Set<Product> products = prodclass != -1 ? intToProducts(prodclass) : null;
+                            locations.add(new Location(LocationType.STATION, id, lat, lon, placeAndName[0],
+                                    placeAndName[1], products));
+                        }
+                    }
+                }
+
+                final JSONArray aPOIs = head.optJSONArray("pois");
+                if (aPOIs != null) {
+                    final int nPOIs = aPOIs.length();
+
+                    for (int i = 0; i < nPOIs; i++) {
+                        final JSONObject poi = aPOIs.optJSONObject(i);
+                        final String id = poi.getString("extId");
+                        // final String name = ParserUtils.resolveEntities(stop.getString("name"));
+                        final String urlname = ParserUtils.urlDecode(poi.getString("urlname"),
+                                jsonNearbyLocationsEncoding);
+                        final int lat = poi.getInt("y");
+                        final int lon = poi.getInt("x");
+
+                        final String[] placeAndName = splitPOI(urlname);
+                        locations.add(new Location(LocationType.POI, id, lat, lon, placeAndName[0], placeAndName[1]));
+                    }
+                }
+
+                return new NearbyLocationsResult(null, locations);
+            } else {
+                log.debug("Hafas error: {}", error);
+                if (error == 2)
+                    return new NearbyLocationsResult(null, NearbyLocationsResult.Status.SERVICE_DOWN);
+                else
+                    throw new RuntimeException("unknown error: " + error);
+            }
+        } catch (final JSONException x) {
+            x.printStackTrace();
+            throw new RuntimeException("cannot parse: '" + page + "' on " + url, x);
+        }
+    }
+
+    protected AbstractHafasProvider setHtmlNearbyStationsPattern(final Pattern htmlNearbyStationsPattern) {
+        this.htmlNearbyStationsPattern = htmlNearbyStationsPattern;
+        return this;
+    }
+
+    private Pattern htmlNearbyStationsPattern = Pattern.compile("<tr class=\"(zebra[^\"]*)\">(.*?)</tr>",
+            Pattern.DOTALL);
+
+    private static final Pattern P_HTML_NEARBY_FINE_COORDS = Pattern
+            .compile("REQMapRoute0\\.Location0\\.X=(-?\\d+)&(?:amp;)?REQMapRoute0\\.Location0\\.Y=(-?\\d+)&");
+    private static final Pattern P_HTML_NEARBY_STATIONS_FINE_LOCATION = Pattern
+            .compile("[\\?&;]input=(\\d+)&[^\"]*\">([^<]*)<");
+    private static final Pattern P_HTML_NEARBY_STATIONS_MESSAGES = Pattern
+            .compile("(Ihre Eingabe kann nicht interpretiert werden)");
+
+    protected final NearbyLocationsResult htmlNearbyStations(final HttpUrl url) throws IOException {
+        final List<Location> stations = new ArrayList<Location>();
+
+        final CharSequence page = httpClient.get(url);
+        String oldZebra = null;
+
+        final Matcher mCoarse = htmlNearbyStationsPattern.matcher(page);
+
+        final Matcher mMessage = P_HTML_NEARBY_STATIONS_MESSAGES.matcher(page);
+        if (mMessage.find()) {
+            if (mMessage.group(1) != null)
+                return new NearbyLocationsResult(null, NearbyLocationsResult.Status.INVALID_ID);
+        }
+
+        while (mCoarse.find()) {
+            final String zebra = mCoarse.group(1);
+            if (oldZebra != null && zebra.equals(oldZebra))
+                throw new IllegalArgumentException("missed row? last:" + zebra);
+            else
+                oldZebra = zebra;
+
+            final Matcher mFineLocation = P_HTML_NEARBY_STATIONS_FINE_LOCATION.matcher(mCoarse.group(2));
+
+            if (mFineLocation.find()) {
+                int parsedLon = 0;
+                int parsedLat = 0;
+                final String parsedId = mFineLocation.group(1);
+                final String parsedName = ParserUtils.resolveEntities(mFineLocation.group(2));
+
+                final Matcher mFineCoords = P_HTML_NEARBY_FINE_COORDS.matcher(mCoarse.group(2));
+
+                if (mFineCoords.find()) {
+                    parsedLon = Integer.parseInt(mFineCoords.group(1));
+                    parsedLat = Integer.parseInt(mFineCoords.group(2));
+                }
+
+                final String[] placeAndName = splitStationName(parsedName);
+                stations.add(new Location(LocationType.STATION, parsedId, parsedLat, parsedLon, placeAndName[0],
+                        placeAndName[1]));
+            } else {
+                throw new IllegalArgumentException("cannot parse '" + mCoarse.group(2) + "' on " + url);
+            }
+        }
+
+        return new NearbyLocationsResult(null, stations);
+    }
+
+    private static final Pattern P_LINE_SBAHN = Pattern.compile("SN?\\d*");
+    private static final Pattern P_LINE_TRAM = Pattern.compile("STR\\w{0,5}");
+    private static final Pattern P_LINE_BUS = Pattern.compile("BUS\\w{0,5}");
+    private static final Pattern P_LINE_TAXI = Pattern.compile("TAX\\w{0,5}");
+
+    protected Product normalizeType(final String type) {
+        final String ucType = type.toUpperCase();
+
+        // Intercity
+        if ("EC".equals(ucType)) // EuroCity
+            return Product.HIGH_SPEED_TRAIN;
+        if ("EN".equals(ucType)) // EuroNight
+            return Product.HIGH_SPEED_TRAIN;
+        if ("D".equals(ucType)) // EuroNight, Sitzwagenabteil
+            return Product.HIGH_SPEED_TRAIN;
+        if ("EIC".equals(ucType)) // Ekspres InterCity, Polen
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ICE".equals(ucType)) // InterCityExpress
+            return Product.HIGH_SPEED_TRAIN;
+        if ("IC".equals(ucType)) // InterCity
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ICT".equals(ucType)) // InterCity
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ICN".equals(ucType)) // InterCityNight
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ICD".equals(ucType)) // Intercity direkt Amsterdam-Breda
+            return Product.HIGH_SPEED_TRAIN;
+        if ("CNL".equals(ucType)) // CityNightLine
+            return Product.HIGH_SPEED_TRAIN;
+        if ("MT".equals(ucType)) // Schnee-Express
+            return Product.HIGH_SPEED_TRAIN;
+        if ("OEC".equals(ucType)) // ÖBB-EuroCity
+            return Product.HIGH_SPEED_TRAIN;
+        if ("OIC".equals(ucType)) // ÖBB-InterCity
+            return Product.HIGH_SPEED_TRAIN;
+        if ("RJ".equals(ucType)) // RailJet, Österreichische Bundesbahnen
+            return Product.HIGH_SPEED_TRAIN;
+        if ("WB".equals(ucType)) // westbahn
+            return Product.HIGH_SPEED_TRAIN;
+        if ("THA".equals(ucType)) // Thalys
+            return Product.HIGH_SPEED_TRAIN;
+        if ("TGV".equals(ucType)) // Train à Grande Vitesse
+            return Product.HIGH_SPEED_TRAIN;
+        if ("DNZ".equals(ucType)) // Nacht-Schnellzug
+            return Product.HIGH_SPEED_TRAIN;
+        if ("AIR".equals(ucType)) // Generic Flight
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ECB".equals(ucType)) // EC, Verona-München
+            return Product.HIGH_SPEED_TRAIN;
+        if ("LYN".equals(ucType)) // Dänemark
+            return Product.HIGH_SPEED_TRAIN;
+        if ("NZ".equals(ucType)) // Schweden, Nacht
+            return Product.HIGH_SPEED_TRAIN;
+        if ("INZ".equals(ucType)) // Nacht
+            return Product.HIGH_SPEED_TRAIN;
+        if ("RHI".equals(ucType)) // ICE
+            return Product.HIGH_SPEED_TRAIN;
+        if ("RHT".equals(ucType)) // TGV
+            return Product.HIGH_SPEED_TRAIN;
+        if ("TGD".equals(ucType)) // TGV
+            return Product.HIGH_SPEED_TRAIN;
+        if ("IRX".equals(ucType)) // IC
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ES".equals(ucType)) // Eurostar Italia
+            return Product.HIGH_SPEED_TRAIN;
+        if ("EST".equals(ucType)) // Eurostar Frankreich
+            return Product.HIGH_SPEED_TRAIN;
+        if ("EM".equals(ucType)) // Euromed, Barcelona-Alicante, Spanien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("A".equals(ucType)) // Spain, Highspeed
+            return Product.HIGH_SPEED_TRAIN;
+        if ("AVE".equals(ucType)) // Alta Velocidad Española, Spanien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ARC".equals(ucType)) // Arco (Renfe), Spanien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ALS".equals(ucType)) // Alaris (Renfe), Spanien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("ATR".equals(ucType)) // Altaria (Renfe), Spanien
+            return Product.REGIONAL_TRAIN;
+        if ("TAL".equals(ucType)) // Talgo, Spanien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("TLG".equals(ucType)) // Spanien, Madrid
+            return Product.HIGH_SPEED_TRAIN;
+        if ("HOT".equals(ucType)) // Spanien, Nacht
+            return Product.HIGH_SPEED_TRAIN;
+        if ("X2".equals(ucType)) // X2000 Neigezug, Schweden
+            return Product.HIGH_SPEED_TRAIN;
+        if ("X".equals(ucType)) // InterConnex
+            return Product.HIGH_SPEED_TRAIN;
+        if ("FYR".equals(ucType)) // Fyra, Amsterdam-Schiphol-Rotterdam
+            return Product.HIGH_SPEED_TRAIN;
+        if ("FYRA".equals(ucType)) // Fyra, Amsterdam-Schiphol-Rotterdam
+            return Product.HIGH_SPEED_TRAIN;
+        if ("SC".equals(ucType)) // SuperCity, Tschechien
+            return Product.HIGH_SPEED_TRAIN;
+        if ("LE".equals(ucType)) // LEO Express, Prag
+            return Product.HIGH_SPEED_TRAIN;
+        if ("FLUG".equals(ucType))
+            return Product.HIGH_SPEED_TRAIN;
+        if ("TLK".equals(ucType)) // Tanie Linie Kolejowe, Polen
+            return Product.HIGH_SPEED_TRAIN;
+        if ("PKP".equals(ucType)) // Polskie Koleje Państwowe (Polnische Staatsbahnen)
+            return Product.HIGH_SPEED_TRAIN;
+        if ("EIP".equals(ucType)) // Express Intercity Premium
+            return Product.HIGH_SPEED_TRAIN;
+        if ("INT".equals(ucType)) // Zürich-Brüssel - Budapest-Istanbul
+            return Product.HIGH_SPEED_TRAIN;
+        if ("HKX".equals(ucType)) // Hamburg-Koeln-Express
+            return Product.HIGH_SPEED_TRAIN;
+        if ("LOC".equals(ucType)) // Locomore
+            return Product.HIGH_SPEED_TRAIN;
+
+        // Regional
+        if ("ZUG".equals(ucType)) // Generic Train
+            return Product.REGIONAL_TRAIN;
+        if ("R".equals(ucType)) // Generic Regional Train
+            return Product.REGIONAL_TRAIN;
+        if ("DPN".equals(ucType)) // Dritter Personen Nahverkehr
+            return Product.REGIONAL_TRAIN;
+        if ("RB".equals(ucType)) // RegionalBahn
+            return Product.REGIONAL_TRAIN;
+        if ("RE".equals(ucType)) // RegionalExpress
+            return Product.REGIONAL_TRAIN;
+        if ("ER".equals(ucType))
+            return Product.REGIONAL_TRAIN;
+        if ("DB".equals(ucType))
+            return Product.REGIONAL_TRAIN;
+        if ("IR".equals(ucType)) // Interregio
+            return Product.REGIONAL_TRAIN;
+        if ("IRE".equals(ucType)) // Interregio Express
+            return Product.REGIONAL_TRAIN;
+        if ("HEX".equals(ucType)) // Harz-Berlin-Express, Veolia
+            return Product.REGIONAL_TRAIN;
+        if ("WFB".equals(ucType)) // Westfalenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("RT".equals(ucType)) // RegioTram
+            return Product.REGIONAL_TRAIN;
+        if ("REX".equals(ucType)) // RegionalExpress, Österreich
+            return Product.REGIONAL_TRAIN;
+        if ("OS".equals(ucType)) // Osobný vlak, Slovakia oder Osobní vlak, Czech Republic
+            return Product.REGIONAL_TRAIN;
+        if ("SP".equals(ucType)) // Spěšný vlak, Czech Republic
+            return Product.REGIONAL_TRAIN;
+        if ("RX".equals(ucType)) // Express, Czech Republic
+            return Product.REGIONAL_TRAIN;
+        if ("EZ".equals(ucType)) // ÖBB ErlebnisBahn
+            return Product.REGIONAL_TRAIN;
+        if ("ARZ".equals(ucType)) // Auto-Reisezug Brig - Iselle di Trasquera
+            return Product.REGIONAL_TRAIN;
+        if ("OE".equals(ucType)) // Ostdeutsche Eisenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("MR".equals(ucType)) // Märkische Regionalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("PE".equals(ucType)) // Prignitzer Eisenbahn GmbH
+            return Product.REGIONAL_TRAIN;
+        if ("NE".equals(ucType)) // NEB Betriebsgesellschaft mbH
+            return Product.REGIONAL_TRAIN;
+        if ("MRB".equals(ucType)) // Mitteldeutsche Regiobahn
+            return Product.REGIONAL_TRAIN;
+        if ("ERB".equals(ucType)) // eurobahn (Keolis Deutschland)
+            return Product.REGIONAL_TRAIN;
+        if ("HLB".equals(ucType)) // Hessische Landesbahn
+            return Product.REGIONAL_TRAIN;
+        if ("VIA".equals(ucType))
+            return Product.REGIONAL_TRAIN;
+        if ("HSB".equals(ucType)) // Harzer Schmalspurbahnen
+            return Product.REGIONAL_TRAIN;
+        if ("OSB".equals(ucType)) // Ortenau-S-Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("VBG".equals(ucType)) // Vogtlandbahn
+            return Product.REGIONAL_TRAIN;
+        if ("AKN".equals(ucType)) // AKN Eisenbahn AG
+            return Product.REGIONAL_TRAIN;
+        if ("OLA".equals(ucType)) // Ostseeland Verkehr
+            return Product.REGIONAL_TRAIN;
+        if ("UBB".equals(ucType)) // Usedomer Bäderbahn
+            return Product.REGIONAL_TRAIN;
+        if ("PEG".equals(ucType)) // Prignitzer Eisenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("NWB".equals(ucType)) // NordWestBahn
+            return Product.REGIONAL_TRAIN;
+        if ("CAN".equals(ucType)) // cantus Verkehrsgesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("BRB".equals(ucType)) // ABELLIO Rail
+            return Product.REGIONAL_TRAIN;
+        if ("SBB".equals(ucType)) // Schweizerische Bundesbahnen
+            return Product.REGIONAL_TRAIN;
+        if ("VEC".equals(ucType)) // vectus Verkehrsgesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("TLX".equals(ucType)) // Trilex (Vogtlandbahn)
+            return Product.REGIONAL_TRAIN;
+        if ("TL".equals(ucType)) // Trilex (Vogtlandbahn)
+            return Product.REGIONAL_TRAIN;
+        if ("HZL".equals(ucType)) // Hohenzollerische Landesbahn
+            return Product.REGIONAL_TRAIN;
+        if ("ABR".equals(ucType)) // Bayerische Regiobahn
+            return Product.REGIONAL_TRAIN;
+        if ("CB".equals(ucType)) // City Bahn Chemnitz
+            return Product.REGIONAL_TRAIN;
+        if ("WEG".equals(ucType)) // Württembergische Eisenbahn-Gesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("NEB".equals(ucType)) // Niederbarnimer Eisenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("ME".equals(ucType)) // metronom Eisenbahngesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("MER".equals(ucType)) // metronom regional
+            return Product.REGIONAL_TRAIN;
+        if ("ALX".equals(ucType)) // Arriva-Länderbahn-Express
+            return Product.REGIONAL_TRAIN;
+        if ("EB".equals(ucType)) // Erfurter Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("EBX".equals(ucType)) // Erfurter Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("VEN".equals(ucType)) // Rhenus Veniro
+            return Product.REGIONAL_TRAIN;
+        if ("BOB".equals(ucType)) // Bayerische Oberlandbahn
+            return Product.REGIONAL_TRAIN;
+        if ("SBS".equals(ucType)) // Städtebahn Sachsen
+            return Product.REGIONAL_TRAIN;
+        if ("SES".equals(ucType)) // Städtebahn Sachsen Express
+            return Product.REGIONAL_TRAIN;
+        if ("EVB".equals(ucType)) // Eisenbahnen und Verkehrsbetriebe Elbe-Weser
+            return Product.REGIONAL_TRAIN;
+        if ("STB".equals(ucType)) // Süd-Thüringen-Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("AG".equals(ucType)) // Ingolstadt-Landshut
+            return Product.REGIONAL_TRAIN;
+        if ("PRE".equals(ucType)) // Pressnitztalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("DBG".equals(ucType)) // Döllnitzbahn GmbH
+            return Product.REGIONAL_TRAIN;
+        if ("SHB".equals(ucType)) // Schleswig-Holstein-Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("NOB".equals(ucType)) // Nord-Ostsee-Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("RTB".equals(ucType)) // Rurtalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("BLB".equals(ucType)) // Berchtesgadener Land Bahn
+            return Product.REGIONAL_TRAIN;
+        if ("NBE".equals(ucType)) // Nordbahn Eisenbahngesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("SOE".equals(ucType)) // Sächsisch-Oberlausitzer Eisenbahngesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("SDG".equals(ucType)) // Sächsische Dampfeisenbahngesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("VE".equals(ucType)) // Lutherstadt Wittenberg
+            return Product.REGIONAL_TRAIN;
+        if ("DAB".equals(ucType)) // Daadetalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("WTB".equals(ucType)) // Wutachtalbahn e.V.
+            return Product.REGIONAL_TRAIN;
+        if ("BE".equals(ucType)) // Grensland-Express
+            return Product.REGIONAL_TRAIN;
+        if ("ARR".equals(ucType)) // Ostfriesland
+            return Product.REGIONAL_TRAIN;
+        if ("HTB".equals(ucType)) // Hörseltalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("FEG".equals(ucType)) // Freiberger Eisenbahngesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("NEG".equals(ucType)) // Norddeutsche Eisenbahngesellschaft Niebüll
+            return Product.REGIONAL_TRAIN;
+        if ("RBG".equals(ucType)) // Regental Bahnbetriebs GmbH
+            return Product.REGIONAL_TRAIN;
+        if ("MBB".equals(ucType)) // Mecklenburgische Bäderbahn Molli
+            return Product.REGIONAL_TRAIN;
+        if ("VEB".equals(ucType)) // Vulkan-Eifel-Bahn Betriebsgesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("LEO".equals(ucType)) // Chiemgauer Lokalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("VX".equals(ucType)) // Vogtland Express
+            return Product.REGIONAL_TRAIN;
+        if ("MSB".equals(ucType)) // Mainschleifenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("P".equals(ucType)) // Kasbachtalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("ÖBA".equals(ucType)) // Öchsle-Bahn Betriebsgesellschaft
+            return Product.REGIONAL_TRAIN;
+        if ("KTB".equals(ucType)) // Kandertalbahn
+            return Product.REGIONAL_TRAIN;
+        if ("ERX".equals(ucType)) // erixx
+            return Product.REGIONAL_TRAIN;
+        if ("ATZ".equals(ucType)) // Autotunnelzug
+            return Product.REGIONAL_TRAIN;
+        if ("ATB".equals(ucType)) // Autoschleuse Tauernbahn
+            return Product.REGIONAL_TRAIN;
+        if ("CAT".equals(ucType)) // City Airport Train
+            return Product.REGIONAL_TRAIN;
+        if ("EXTRA".equals(ucType) || "EXT".equals(ucType)) // Extrazug
+            return Product.REGIONAL_TRAIN;
+        if ("KD".equals(ucType)) // Koleje Dolnośląskie (Niederschlesische Eisenbahn)
+            return Product.REGIONAL_TRAIN;
+        if ("KM".equals(ucType)) // Koleje Mazowieckie
+            return Product.REGIONAL_TRAIN;
+        if ("EX".equals(ucType)) // Polen
+            return Product.REGIONAL_TRAIN;
+        if ("PCC".equals(ucType)) // PCC Rail, Polen
+            return Product.REGIONAL_TRAIN;
+        if ("ZR".equals(ucType)) // ZSR (Slovakian Republic Railways)
+            return Product.REGIONAL_TRAIN;
+        if ("RNV".equals(ucType)) // Rhein-Neckar-Verkehr GmbH
+            return Product.REGIONAL_TRAIN;
+        if ("DWE".equals(ucType)) // Dessau-Wörlitzer Eisenbahn
+            return Product.REGIONAL_TRAIN;
+        if ("BKB".equals(ucType)) // Buckower Kleinbahn
+            return Product.REGIONAL_TRAIN;
+        if ("GEX".equals(ucType)) // Glacier Express
+            return Product.REGIONAL_TRAIN;
+        if ("M".equals(ucType)) // Meridian
+            return Product.REGIONAL_TRAIN;
+        if ("WBA".equals(ucType)) // Waldbahn
+            return Product.REGIONAL_TRAIN;
+        if ("BEX".equals(ucType)) // Bernina Express
+            return Product.REGIONAL_TRAIN;
+        if ("VAE".equals(ucType)) // Voralpen-Express
+            return Product.REGIONAL_TRAIN;
+        if ("OPB".equals(ucType)) // oberpfalzbahn
+            return Product.REGIONAL_TRAIN;
+        if ("OPX".equals(ucType)) // oberpfalz-express
+            return Product.REGIONAL_TRAIN;
+        if ("TER".equals(ucType)) // Transport express régional
+            return Product.REGIONAL_TRAIN;
+        if ("ENO".equals(ucType))
+            return Product.REGIONAL_TRAIN;
+        if ("THU".equals(ucType)) // Thurbo AG
+            return Product.REGIONAL_TRAIN;
+        if ("GW".equals(ucType)) // gwtr.cz
+            return Product.REGIONAL_TRAIN;
+        if ("SE".equals(ucType)) // ABELLIO Rail Mitteldeutschland GmbH
+            return Product.REGIONAL_TRAIN;
+        if ("UEX".equals(ucType)) // Slovenia
+            return Product.REGIONAL_TRAIN;
+
+        // Suburban Trains
+        if (P_LINE_SBAHN.matcher(ucType).matches()) // Generic (Night) S-Bahn
+            return Product.SUBURBAN_TRAIN;
+        if ("S-BAHN".equals(ucType))
+            return Product.SUBURBAN_TRAIN;
+        if ("BSB".equals(ucType)) // Breisgau S-Bahn
+            return Product.SUBURBAN_TRAIN;
+        if ("SWE".equals(ucType)) // Südwestdeutsche Verkehrs-AG, Ortenau-S-Bahn
+            return Product.SUBURBAN_TRAIN;
+        if ("RER".equals(ucType)) // Réseau Express Régional, Frankreich
+            return Product.SUBURBAN_TRAIN;
+        if ("WKD".equals(ucType)) // Warszawska Kolej Dojazdowa (Warsaw Suburban Railway)
+            return Product.SUBURBAN_TRAIN;
+        if ("SKM".equals(ucType)) // Szybka Kolej Miejska Tricity
+            return Product.SUBURBAN_TRAIN;
+        if ("SKW".equals(ucType)) // Szybka Kolej Miejska Warschau
+            return Product.SUBURBAN_TRAIN;
+
+        // Subway
+        if ("U".equals(ucType)) // Generic U-Bahn
+            return Product.SUBWAY;
+        if ("MET".equals(ucType))
+            return Product.SUBWAY;
+        if ("METRO".equals(ucType))
+            return Product.SUBWAY;
+
+        // Tram
+        if (P_LINE_TRAM.matcher(ucType).matches()) // Generic Tram
+            return Product.TRAM;
+        if ("NFT".equals(ucType)) // Niederflur-Tram
+            return Product.TRAM;
+        if ("TRAM".equals(ucType))
+            return Product.TRAM;
+        if ("TRA".equals(ucType))
+            return Product.TRAM;
+        if ("WLB".equals(ucType)) // Wiener Lokalbahnen
+            return Product.TRAM;
+        if ("STRWLB".equals(ucType)) // Wiener Lokalbahnen
+            return Product.TRAM;
+        if ("SCHW-B".equals(ucType)) // Schwebebahn, gilt als "Straßenbahn besonderer Bauart"
+            return Product.TRAM;
+
+        // Bus
+        if (P_LINE_BUS.matcher(ucType).matches()) // Generic Bus
+            return Product.BUS;
+        if ("NFB".equals(ucType)) // Niederflur-Bus
+            return Product.BUS;
+        if ("SEV".equals(ucType)) // Schienen-Ersatz-Verkehr
+            return Product.BUS;
+        if ("BUSSEV".equals(ucType)) // Schienen-Ersatz-Verkehr
+            return Product.BUS;
+        if ("BSV".equals(ucType)) // Bus SEV
+            return Product.BUS;
+        if ("FB".equals(ucType)) // Fernbus? Luxemburg-Saarbrücken
+            return Product.BUS;
+        if ("EXB".equals(ucType)) // Expressbus München-Prag?
+            return Product.BUS;
+        if ("ICB".equals(ucType)) // ÖBB ICBus
+            return Product.BUS;
+        if ("TRO".equals(ucType)) // Trolleybus
+            return Product.BUS;
+        if ("RFB".equals(ucType)) // Rufbus
+            return Product.BUS;
+        if ("RUF".equals(ucType)) // Rufbus
+            return Product.BUS;
+        if (P_LINE_TAXI.matcher(ucType).matches()) // Generic Taxi
+            return Product.BUS;
+        if ("RFT".equals(ucType)) // Ruftaxi
+            return Product.BUS;
+        if ("LT".equals(ucType)) // Linien-Taxi
+            return Product.BUS;
+        if ("NB".equals(ucType)) // Nachtbus Zürich
+            return Product.BUS;
+        if ("POSTBUS".equals(ucType))
+            return Product.BUS;
+
+        // Phone
+        if ("RUFBUS".equals(ucType))
+            return Product.ON_DEMAND;
+        if (ucType.startsWith("AST")) // Anruf-Sammel-Taxi
+            return Product.ON_DEMAND;
+        if (ucType.startsWith("ALT")) // Anruf-Linien-Taxi
+            return Product.ON_DEMAND;
+        if (ucType.startsWith("BUXI")) // Bus-Taxi (Schweiz)
+            return Product.ON_DEMAND;
+        if ("TB".equals(ucType)) // Taxi-Bus?
+            return Product.ON_DEMAND;
+
+        // Ferry
+        if ("SCHIFF".equals(ucType))
+            return Product.FERRY;
+        if ("FÄHRE".equals(ucType))
+            return Product.FERRY;
+        if ("FÄH".equals(ucType))
+            return Product.FERRY;
+        if ("FAE".equals(ucType))
+            return Product.FERRY;
+        if ("SCH".equals(ucType)) // Schiff
+            return Product.FERRY;
+        if ("AS".equals(ucType)) // SyltShuttle
+            return Product.FERRY;
+        if ("AZS".equals(ucType)) // Autozug Sylt Shuttle
+            return Product.FERRY;
+        if ("KAT".equals(ucType)) // Katamaran, e.g. Friedrichshafen - Konstanz
+            return Product.FERRY;
+        if ("BAT".equals(ucType)) // Boots Anlege Terminal?
+            return Product.FERRY;
+        if ("BAV".equals(ucType)) // Boots Anlege?
+            return Product.FERRY;
+
+        // Cable Car
+        if ("SEILBAHN".equals(ucType))
+            return Product.CABLECAR;
+        if ("SB".equals(ucType)) // Seilbahn
+            return Product.CABLECAR;
+        if ("ZAHNR".equals(ucType)) // Zahnradbahn, u.a. Zugspitzbahn
+            return Product.CABLECAR;
+        if ("GB".equals(ucType)) // Gondelbahn
+            return Product.CABLECAR;
+        if ("LB".equals(ucType)) // Luftseilbahn
+            return Product.CABLECAR;
+        if ("FUN".equals(ucType)) // Funiculaire (Standseilbahn)
+            return Product.CABLECAR;
+        if ("SL".equals(ucType)) // Sessel-Lift
+            return Product.CABLECAR;
+
+        // Unknown product
+        if ("E".equals(ucType))
+            return null;
+
+        throw new IllegalStateException("cannot normalize type '" + type + "'");
+    }
+
+    private static final Pattern P_NORMALIZE_LINE_NAME_BUS = Pattern.compile("bus\\s+(.*)", Pattern.CASE_INSENSITIVE);
+    protected static final Pattern P_NORMALIZE_LINE = Pattern
+            .compile("([A-Za-zßÄÅäáàâåéèêíìîÖöóòôÜüúùûØ/]+)[\\s-]*([^#]*).*");
+
+    protected String normalizeLineName(final String lineName) {
+        final Matcher mBus = P_NORMALIZE_LINE_NAME_BUS.matcher(lineName);
+        if (mBus.matches())
+            return mBus.group(1);
+
+        final Matcher m = P_NORMALIZE_LINE.matcher(lineName);
+        if (m.matches())
+            return m.group(1) + m.group(2);
+
+        return lineName;
+    }
+
+    private static final Pattern P_NORMALIZE_LINE_ADMINISTRATION = Pattern.compile("([^_]*)_*");
+
+    private final String normalizeLineAdministration(final String administration) {
+        if (administration == null)
+            return null;
+
+        final Matcher m = P_NORMALIZE_LINE_ADMINISTRATION.matcher(administration);
+        if (m.find())
+            return m.group(1);
+        else
+            return administration;
+    }
+
+    private static final Pattern P_CATEGORY_FROM_NAME = Pattern.compile("([A-Za-zßÄÅäáàâåéèêíìîÖöóòôÜüúùûØ]+).*");
+
+    protected final String categoryFromName(final String lineName) {
+        final Matcher m = P_CATEGORY_FROM_NAME.matcher(lineName);
+        if (m.matches())
+            return m.group(1);
+        else
+            return lineName;
+    }
+
+    private static final Pattern P_NORMALIZE_LINE_BUS = Pattern.compile("(?:Bus|BUS)\\s*(.*)");
+    private static final Pattern P_NORMALIZE_LINE_TRAM = Pattern.compile("(?:Tram|Tra|Str|STR)\\s*(.*)");
+
+    protected Line parseLine(final String type, final String normalizedName, final boolean wheelchairAccess) {
+        if (normalizedName != null) {
+            final Matcher mBus = P_NORMALIZE_LINE_BUS.matcher(normalizedName);
+            if (mBus.matches())
+                return newLine(Product.BUS, mBus.group(1), null);
+
+            final Matcher mTram = P_NORMALIZE_LINE_TRAM.matcher(normalizedName);
+            if (mTram.matches())
+                return newLine(Product.TRAM, mTram.group(1), null);
+        }
+
+        final Product normalizedType = normalizeType(type);
+
+        final Line.Attr[] attrs;
+        if (wheelchairAccess)
+            attrs = new Line.Attr[] { Line.Attr.WHEEL_CHAIR_ACCESS };
+        else
+            attrs = new Line.Attr[0];
+
+        if (normalizedName != null) {
+            final Matcher m = P_NORMALIZE_LINE.matcher(normalizedName);
+            final String strippedLine = m.matches() ? m.group(1) + m.group(2) : normalizedName;
+
+            return newLine(normalizedType, strippedLine, null, attrs);
+        } else {
+            return newLine(normalizedType, null, null, attrs);
+        }
+    }
+
+    protected static final Pattern P_NORMALIZE_LINE_AND_TYPE = Pattern.compile("([^#]*)#(.*)");
+    private static final Pattern P_NORMALIZE_LINE_NUMBER = Pattern.compile("\\d{2,5}");
+
+    protected static final Pattern P_LINE_RUSSIA = Pattern.compile(
+            "\\d{3}(?:AJ|BJ|CJ|DJ|EJ|FJ|GJ|IJ|KJ|LJ|NJ|MJ|OJ|RJ|SJ|TJ|UJ|VJ|ZJ|CH|KH|ZH|EI|JA|JI|MZ|SH|SZ|PC|Y)");
+
+    protected Line parseLineAndType(final String lineAndType) {
+        final Matcher mLineAndType = P_NORMALIZE_LINE_AND_TYPE.matcher(lineAndType);
+        if (mLineAndType.matches()) {
+            final String number = mLineAndType.group(1);
+            final String type = mLineAndType.group(2);
+
+            if (type.length() == 0) {
+                if (number.length() == 0)
+                    return newLine(null, null, null);
+                if (P_NORMALIZE_LINE_NUMBER.matcher(number).matches())
+                    return newLine(null, number, null);
+                if (P_LINE_RUSSIA.matcher(number).matches())
+                    return newLine(Product.REGIONAL_TRAIN, number, null);
+            } else {
+                final Product normalizedType = normalizeType(type);
+                if (normalizedType != null) {
+                    if (normalizedType == Product.BUS) {
+                        final Matcher mBus = P_NORMALIZE_LINE_BUS.matcher(number);
+                        if (mBus.matches())
+                            return newLine(Product.BUS, mBus.group(1), null);
+                    }
+
+                    if (normalizedType == Product.TRAM) {
+                        final Matcher mTram = P_NORMALIZE_LINE_TRAM.matcher(number);
+                        if (mTram.matches())
+                            return newLine(Product.TRAM, mTram.group(1), null);
+                    }
+                }
+
+                return newLine(normalizedType, number.replaceAll("\\s+", ""), null);
+            }
+
+            throw new IllegalStateException(
+                    "cannot normalize type '" + type + "' number '" + number + "' line#type '" + lineAndType + "'");
+        }
+
+        throw new IllegalStateException("cannot normalize line#type '" + lineAndType + "'");
+    }
+
+    protected Line newLine(final Product product, final String normalizedName, final String comment,
+            final Line.Attr... attrs) {
+        return newLine(null, product, normalizedName, comment, attrs);
+    }
+
+    protected Line newLine(final String network, final Product product, final String normalizedName,
+            final String comment, final Line.Attr... attrs) {
+        if (attrs.length == 0) {
+            return new Line(null, network, product, normalizedName, lineStyle(network, product, normalizedName),
+                    comment);
+        } else {
+            final Set<Line.Attr> attrSet = new HashSet<Line.Attr>();
+            for (final Line.Attr attr : attrs)
+                attrSet.add(attr);
+            return new Line(null, network, product, normalizedName, lineStyle(network, product, normalizedName),
+                    attrSet, comment);
+        }
+    }
+}
\ No newline at end of file
diff --git a/enabler/src/de/schildbach/pte/AbstractHafasMobileProvider.java b/enabler/src/de/schildbach/pte/AbstractHafasMobileProvider.java
new file mode 100644
index 00000000..0511774c
--- /dev/null
+++ b/enabler/src/de/schildbach/pte/AbstractHafasMobileProvider.java
@@ -0,0 +1,751 @@
+/*
+ * Copyright 2010-2017 the original author or authors.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package de.schildbach.pte;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Currency;
+import java.util.Date;
+import java.util.EnumSet;
+import java.util.GregorianCalendar;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nullable;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import com.google.common.base.Joiner;
+
+import de.schildbach.pte.dto.Departure;
+import de.schildbach.pte.dto.Fare;
+import de.schildbach.pte.dto.Line;
+import de.schildbach.pte.dto.Location;
+import de.schildbach.pte.dto.LocationType;
+import de.schildbach.pte.dto.NearbyLocationsResult;
+import de.schildbach.pte.dto.Position;
+import de.schildbach.pte.dto.Product;
+import de.schildbach.pte.dto.QueryDeparturesResult;
+import de.schildbach.pte.dto.QueryTripsContext;
+import de.schildbach.pte.dto.QueryTripsResult;
+import de.schildbach.pte.dto.ResultHeader;
+import de.schildbach.pte.dto.StationDepartures;
+import de.schildbach.pte.dto.Stop;
+import de.schildbach.pte.dto.SuggestLocationsResult;
+import de.schildbach.pte.dto.SuggestedLocation;
+import de.schildbach.pte.dto.Trip;
+import de.schildbach.pte.exception.ParserException;
+import de.schildbach.pte.util.ParserUtils;
+
+import okhttp3.HttpUrl;
+
+/**
+ * @author Andreas Schildbach
+ */
+public abstract class AbstractHafasMobileProvider extends AbstractHafasProvider {
+    public HttpUrl mgateEndpoint;
+    @Nullable
+    public String apiVersion;
+    @Nullable
+    public String apiAuthorization;
+    @Nullable
+    public String apiClient;
+
+    public AbstractHafasMobileProvider(final NetworkId network, final HttpUrl apiBase, final Product[] productsMap) {
+        super(network, productsMap);
+        this.mgateEndpoint = apiBase.newBuilder().addPathSegment("mgate.exe").build();
+    }
+
+    protected AbstractHafasMobileProvider setApiVersion(final String apiVersion) {
+        this.apiVersion = apiVersion;
+        return this;
+    }
+
+    protected AbstractHafasMobileProvider setApiAuthorization(final String apiAuthorization) {
+        this.apiAuthorization = apiAuthorization;
+        return this;
+    }
+
+    protected AbstractHafasMobileProvider setApiClient(final String apiClient) {
+        this.apiClient = apiClient;
+        return this;
+    }
+
+    @Override
+    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
+            final int maxDistance, final int maxLocations) throws IOException {
+        if (location.hasLocation())
+            return jsonLocGeoPos(types, location.lat, location.lon);
+        else
+            throw new IllegalArgumentException("cannot handle: " + location);
+    }
+
+    @Override
+    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
+            final int maxDepartures, final boolean equivs) throws IOException {
+        return jsonStationBoard(stationId, time, maxDepartures, equivs);
+    }
+
+    @Override
+    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
+        return jsonLocMatch(constraint);
+    }
+
+    @Override
+    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
+            final Date date, final boolean dep, final @Nullable Set<Product> products,
+            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
+            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
+        return jsonTripSearch(from, via, to, date, dep, products, null);
+    }
+
+    @Override
+    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
+        final JsonContext jsonContext = (JsonContext) context;
+        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
+                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
+    }
+
+    protected final NearbyLocationsResult jsonLocGeoPos(final EnumSet<LocationType> types, final int lat, final int lon)
+            throws IOException {
+        final boolean getPOIs = types.contains(LocationType.POI);
+        final String request = wrapJsonApiRequest("LocGeoPos",
+                "{\"ring\":" //
+                        + "{\"cCrd\":{\"x\":" + lon + ",\"y\":" + lat + "}}," //
+                        + "\"getPOIs\":" + getPOIs + "}", //
+                false);
+
+        final HttpUrl url = checkNotNull(mgateEndpoint);
+        final CharSequence page = httpClient.get(url, request, "application/json");
+
+        try {
+            final JSONObject head = new JSONObject(page.toString());
+            final String headErr = head.optString("err", null);
+            if (headErr != null)
+                throw new RuntimeException(headErr);
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
+
+            final JSONArray svcResList = head.getJSONArray("svcResL");
+            checkState(svcResList.length() == 1);
+            final JSONObject svcRes = svcResList.optJSONObject(0);
+            checkState("LocGeoPos".equals(svcRes.getString("meth")));
+            final String err = svcRes.getString("err");
+            if (!"OK".equals(err)) {
+                final String errTxt = svcRes.getString("errTxt");
+                throw new RuntimeException(err + " " + errTxt);
+            }
+            final JSONObject res = svcRes.getJSONObject("res");
+
+            final JSONObject common = res.getJSONObject("common");
+            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
+
+            final JSONArray locL = res.optJSONArray("locL");
+            final List<Location> locations;
+            if (locL != null) {
+                locations = parseLocList(locL);
+
+                // filter unwanted location types
+                for (Iterator<Location> i = locations.iterator(); i.hasNext();) {
+                    final Location location = i.next();
+                    if (!types.contains(location.type))
+                        i.remove();
+                }
+            } else {
+                locations = Collections.emptyList();
+            }
+
+            return new NearbyLocationsResult(header, locations);
+        } catch (final JSONException x) {
+            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
+        }
+    }
+
+    protected final QueryDeparturesResult jsonStationBoard(final String stationId, final @Nullable Date time,
+            final int maxDepartures, final boolean equivs) throws IOException {
+        final Calendar c = new GregorianCalendar(timeZone);
+        c.setTime(time);
+        final CharSequence jsonDate = jsonDate(c);
+        final CharSequence jsonTime = jsonTime(c);
+        final CharSequence normalizedStationId = normalizeStationId(stationId);
+        final CharSequence stbFltrEquiv = Boolean.toString(!equivs);
+        final CharSequence maxJny = Integer.toString(maxDepartures != 0 ? maxDepartures : DEFAULT_MAX_DEPARTURES);
+        final CharSequence getPasslist = Boolean.toString(true); // traffic expensive
+        final String request = wrapJsonApiRequest("StationBoard",
+                "{\"type\":\"DEP\"," //
+                        + "\"date\":\"" + jsonDate + "\"," //
+                        + "\"time\":\"" + jsonTime + "\"," //
+                        + "\"stbLoc\":{\"type\":\"S\"," + "\"state\":\"F\"," // F/M
+                        + "\"extId\":" + JSONObject.quote(normalizedStationId.toString()) + "}," //
+                        + "\"stbFltrEquiv\":" + stbFltrEquiv + ",\"maxJny\":" + maxJny + ",\"getPasslist\":"
+                        + getPasslist + "}",
+                false);
+
+        final HttpUrl url = checkNotNull(mgateEndpoint);
+        final CharSequence page = httpClient.get(url, request, "application/json");
+
+        try {
+            final JSONObject head = new JSONObject(page.toString());
+            final String headErr = head.optString("err", null);
+            if (headErr != null)
+                throw new RuntimeException(headErr);
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
+            final QueryDeparturesResult result = new QueryDeparturesResult(header);
+
+            final JSONArray svcResList = head.getJSONArray("svcResL");
+            checkState(svcResList.length() == 1);
+            final JSONObject svcRes = svcResList.optJSONObject(0);
+            checkState("StationBoard".equals(svcRes.getString("meth")));
+            final String err = svcRes.getString("err");
+            if (!"OK".equals(err)) {
+                final String errTxt = svcRes.getString("errTxt");
+                log.debug("Hafas error: {} {}", err, errTxt);
+                if ("LOCATION".equals(err) && "HCI Service: location missing or invalid".equals(errTxt))
+                    return new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION);
+                if ("FAIL".equals(err) && "HCI Service: request failed".equals(errTxt))
+                    return new QueryDeparturesResult(header, QueryDeparturesResult.Status.SERVICE_DOWN);
+                throw new RuntimeException(err + " " + errTxt);
+            } else if ("1.10".equals(apiVersion) && svcRes.toString().length() == 170) {
+                // horrible hack, because API version 1.10 doesn't signal invalid stations via error
+                return new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION);
+            }
+            final JSONObject res = svcRes.getJSONObject("res");
+
+            final JSONObject common = res.getJSONObject("common");
+            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
+            final List<String> operators = parseOpList(common.getJSONArray("opL"));
+            final List<Line> lines = parseProdList(common.getJSONArray("prodL"), operators);
+            final JSONArray locList = common.getJSONArray("locL");
+            final List<Location> locations = parseLocList(locList);
+
+            final JSONArray jnyList = res.optJSONArray("jnyL");
+            if (jnyList != null) {
+                for (int iJny = 0; iJny < jnyList.length(); iJny++) {
+                    final JSONObject jny = jnyList.getJSONObject(iJny);
+                    final JSONObject stbStop = jny.getJSONObject("stbStop");
+
+                    final String stbStopPlatformS = stbStop.optString("dPlatfS", null);
+                    c.clear();
+                    ParserUtils.parseIsoDate(c, jny.getString("date"));
+                    final Date baseDate = c.getTime();
+
+                    final Date plannedTime = parseJsonTime(c, baseDate, stbStop.getString("dTimeS"));
+
+                    final Date predictedTime = parseJsonTime(c, baseDate, stbStop.optString("dTimeR", null));
+
+                    final Line line = lines.get(stbStop.getInt("dProdX"));
+
+                    final Location location = equivs ? locations.get(stbStop.getInt("locX"))
+                            : new Location(LocationType.STATION, stationId);
+                    final Position position = normalizePosition(stbStopPlatformS);
+
+                    final String jnyDirTxt = jny.getString("dirTxt");
+                    final JSONArray stopList = jny.optJSONArray("stopL");
+                    final Location destination;
+                    if (stopList != null) {
+                        final int lastStopIdx = stopList.getJSONObject(stopList.length() - 1).getInt("locX");
+                        final String lastStopName = locList.getJSONObject(lastStopIdx).getString("name");
+                        if (jnyDirTxt.equals(lastStopName))
+                            destination = locations.get(lastStopIdx);
+                        else
+                            destination = new Location(LocationType.ANY, null, null, jnyDirTxt);
+                    } else {
+                        destination = new Location(LocationType.ANY, null, null, jnyDirTxt);
+                    }
+
+                    final Departure departure = new Departure(plannedTime, predictedTime, line, position, destination,
+                            null, null);
+
+                    StationDepartures stationDepartures = findStationDepartures(result.stationDepartures, location);
+                    if (stationDepartures == null) {
+                        stationDepartures = new StationDepartures(location, new ArrayList<Departure>(8), null);
+                        result.stationDepartures.add(stationDepartures);
+                    }
+
+                    stationDepartures.departures.add(departure);
+                }
+            }
+
+            // sort departures
+            for (final StationDepartures stationDepartures : result.stationDepartures)
+                Collections.sort(stationDepartures.departures, Departure.TIME_COMPARATOR);
+
+            return result;
+        } catch (final JSONException x) {
+            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
+        }
+    }
+
+    protected final SuggestLocationsResult jsonLocMatch(final CharSequence constraint) throws IOException {
+        final String request = wrapJsonApiRequest("LocMatch",
+                "{\"input\":{\"field\":\"S\",\"loc\":{\"name\":" + JSONObject.quote(checkNotNull(constraint).toString())
+                        + ",\"meta\":false},\"maxLoc\":" + DEFAULT_MAX_LOCATIONS + "}}",
+                true);
+
+        final HttpUrl url = checkNotNull(mgateEndpoint);
+        final CharSequence page = httpClient.get(url, request, "application/json");
+
+        try {
+            final JSONObject head = new JSONObject(page.toString());
+            final String headErr = head.optString("err", null);
+            if (headErr != null)
+                throw new RuntimeException(headErr);
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
+
+            final JSONArray svcResList = head.getJSONArray("svcResL");
+            checkState(svcResList.length() == 1);
+            final JSONObject svcRes = svcResList.optJSONObject(0);
+            checkState("LocMatch".equals(svcRes.getString("meth")));
+            final String err = svcRes.getString("err");
+            if (!"OK".equals(err)) {
+                final String errTxt = svcRes.getString("errTxt");
+                throw new RuntimeException(err + " " + errTxt);
+            }
+            final JSONObject res = svcRes.getJSONObject("res");
+
+            final JSONObject common = res.getJSONObject("common");
+            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
+
+            final JSONObject match = res.getJSONObject("match");
+            final List<Location> locations = parseLocList(match.optJSONArray("locL"));
+            final List<SuggestedLocation> suggestedLocations = new ArrayList<SuggestedLocation>(locations.size());
+            for (final Location location : locations)
+                suggestedLocations.add(new SuggestedLocation(location));
+            // TODO weight
+
+            return new SuggestLocationsResult(header, suggestedLocations);
+        } catch (final JSONException x) {
+            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
+        }
+    }
+
+    private static final Joiner JOINER = Joiner.on(' ').skipNulls();
+
+    protected final QueryTripsResult jsonTripSearch(Location from, @Nullable Location via, Location to, final Date time,
+            final boolean dep, final @Nullable Set<Product> products, final String moreContext) throws IOException {
+        if (!from.hasId() && from.hasName()) {
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+            final List<Location> locations = suggestLocations(JOINER.join(from.place, from.name)).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM);
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, locations, null, null);
+            from = locations.get(0);
+        }
+
+        if (via != null && !via.hasId() && via.hasName()) {
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+            final List<Location> locations = suggestLocations(JOINER.join(via.place, via.name)).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA);
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, locations, null, null);
+            via = locations.get(0);
+        }
+
+        if (!to.hasId() && to.hasName()) {
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
+            final List<Location> locations = suggestLocations(JOINER.join(to.place, to.name)).getLocations();
+            if (locations.isEmpty())
+                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO);
+            if (locations.size() > 1)
+                return new QueryTripsResult(header, null, null, locations);
+            to = locations.get(0);
+        }
+
+        final Calendar c = new GregorianCalendar(timeZone);
+        c.setTime(time);
+        final CharSequence outDate = jsonDate(c);
+        final CharSequence outTime = jsonTime(c);
+        final CharSequence outFrwdKey = "1.11".equals(apiVersion) ? "outFrwd" : "frwd";
+        final CharSequence outFrwd = Boolean.toString(dep);
+        final CharSequence jnyFltr = productsString(products);
+        final CharSequence jsonContext = moreContext != null ? "\"ctxScr\":" + JSONObject.quote(moreContext) + "," : "";
+        final String request = wrapJsonApiRequest("TripSearch", "{" //
+                + jsonContext //
+                + "\"depLocL\":[" + jsonLocation(from) + "]," //
+                + "\"arrLocL\":[" + jsonLocation(to) + "]," //
+                + (via != null ? "\"viaLocL\":[{\"loc\":" + jsonLocation(via) + "}]," : "") //
+                + "\"outDate\":\"" + outDate + "\"," //
+                + "\"outTime\":\"" + outTime + "\"," //
+                + "\"" + outFrwdKey + "\":" + outFrwd + "," //
+                + "\"jnyFltrL\":[{\"value\":\"" + jnyFltr + "\",\"mode\":\"BIT\",\"type\":\"PROD\"}]," //
+                + "\"gisFltrL\":[{\"mode\":\"FB\",\"profile\":{\"type\":\"F\",\"linDistRouting\":false,\"maxdist\":2000},\"type\":\"P\"}]," //
+                + "\"getPolyline\":false,\"getPasslist\":true,\"getIST\":false,\"getEco\":false,\"extChgTime\":-1}", //
+                false);
+
+        final HttpUrl url = checkNotNull(mgateEndpoint);
+        final CharSequence page = httpClient.get(url, request, "application/json");
+
+        try {
+            final JSONObject head = new JSONObject(page.toString());
+            final String headErr = head.optString("err", null);
+            if (headErr != null)
+                throw new RuntimeException(headErr);
+            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
+
+            final JSONArray svcResList = head.getJSONArray("svcResL");
+            checkState(svcResList.length() == 1);
+            final JSONObject svcRes = svcResList.optJSONObject(0);
+            checkState("TripSearch".equals(svcRes.getString("meth")));
+            final String err = svcRes.getString("err");
+            if (!"OK".equals(err)) {
+                final String errTxt = svcRes.getString("errTxt");
+                log.debug("Hafas error: {} {}", err, errTxt);
+                if ("H890".equals(err)) // No connections found.
+                    return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS);
+                if ("H891".equals(err)) // No route found (try entering an intermediate station).
+                    return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS);
+                if ("H895".equals(err)) // Departure/Arrival are too near.
+                    return new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE);
+                if ("H9220".equals(err)) // Nearby to the given address stations could not be found.
+                    return new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS);
+                if ("H9360".equals(err)) // Date outside of the timetable period.
+                    return new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE);
+                if ("H9380".equals(err)) // Departure/Arrival/Intermediate or equivalent stations def'd more
+                                         // than once.
+                    return new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE);
+                if ("FAIL".equals(err) && "HCI Service: request failed".equals(errTxt))
+                    return new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN);
+                throw new RuntimeException(err + " " + errTxt);
+            }
+            final JSONObject res = svcRes.getJSONObject("res");
+
+            final JSONObject common = res.getJSONObject("common");
+            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
+            final List<Location> locations = parseLocList(common.getJSONArray("locL"));
+            final List<String> operators = parseOpList(common.getJSONArray("opL"));
+            final List<Line> lines = parseProdList(common.getJSONArray("prodL"), operators);
+
+            final JSONArray outConList = res.optJSONArray("outConL");
+            final List<Trip> trips = new ArrayList<Trip>(outConList.length());
+            for (int iOutCon = 0; iOutCon < outConList.length(); iOutCon++) {
+                final JSONObject outCon = outConList.getJSONObject(iOutCon);
+                final Location tripFrom = locations.get(outCon.getJSONObject("dep").getInt("locX"));
+                final Location tripTo = locations.get(outCon.getJSONObject("arr").getInt("locX"));
+
+                c.clear();
+                ParserUtils.parseIsoDate(c, outCon.getString("date"));
+                final Date baseDate = c.getTime();
+
+                final JSONArray secList = outCon.optJSONArray("secL");
+                final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(secList.length());
+                for (int iSec = 0; iSec < secList.length(); iSec++) {
+                    final JSONObject sec = secList.getJSONObject(iSec);
+                    final String secType = sec.getString("type");
+
+                    final JSONObject secDep = sec.getJSONObject("dep");
+                    final Stop departureStop = parseJsonStop(secDep, locations, c, baseDate);
+
+                    final JSONObject secArr = sec.getJSONObject("arr");
+                    final Stop arrivalStop = parseJsonStop(secArr, locations, c, baseDate);
+
+                    final Trip.Leg leg;
+                    if ("JNY".equals(secType)) {
+                        final JSONObject jny = sec.getJSONObject("jny");
+                        final Line line = lines.get(jny.getInt("prodX"));
+                        final String dirTxt = jny.optString("dirTxt", null);
+                        final Location destination = dirTxt != null ? new Location(LocationType.ANY, null, null, dirTxt)
+                                : null;
+
+                        final JSONArray stopList = jny.getJSONArray("stopL");
+                        checkState(stopList.length() >= 2);
+                        final List<Stop> intermediateStops = new ArrayList<Stop>(stopList.length());
+                        for (int iStop = 1; iStop < stopList.length() - 1; iStop++) {
+                            final JSONObject stop = stopList.getJSONObject(iStop);
+                            final Stop intermediateStop = parseJsonStop(stop, locations, c, baseDate);
+                            intermediateStops.add(intermediateStop);
+                        }
+
+                        leg = new Trip.Public(line, destination, departureStop, arrivalStop, intermediateStops, null,
+                                null);
+                    } else if ("WALK".equals(secType) || "TRSF".equals(secType)) {
+                        final JSONObject gis = sec.getJSONObject("gis");
+                        final int distance = gis.optInt("dist", 0);
+                        leg = new Trip.Individual(Trip.Individual.Type.WALK, departureStop.location,
+                                departureStop.getDepartureTime(), arrivalStop.location, arrivalStop.getArrivalTime(),
+                                null, distance);
+                    } else {
+                        throw new IllegalStateException("cannot handle type: " + secType);
+                    }
+
+                    legs.add(leg);
+                }
+
+                final JSONObject trfRes = outCon.optJSONObject("trfRes");
+                final List<Fare> fares = new LinkedList<Fare>();
+                if (trfRes != null) {
+                    final JSONArray fareSetList = trfRes.getJSONArray("fareSetL");
+                    for (int iFareSet = 0; iFareSet < fareSetList.length(); iFareSet++) {
+                        final JSONObject fareSet = fareSetList.getJSONObject(iFareSet);
+                        final String fareSetName = fareSet.optString("name", null);
+                        final String fareSetDescription = fareSet.optString("desc", null);
+                        if (fareSetName != null || fareSetDescription != null) {
+                            final JSONArray fareList = fareSet.getJSONArray("fareL");
+                            for (int iFare = 0; iFare < fareList.length(); iFare++) {
+                                final JSONObject jsonFare = fareList.getJSONObject(iFare);
+                                final String name = jsonFare.getString("name");
+                                final Currency currency = Currency.getInstance(jsonFare.getString("cur"));
+                                final float price = jsonFare.getInt("prc") / 100f;
+                                final Fare fare = parseJsonTripFare(fareSetName, fareSetDescription, name, currency,
+                                        price);
+                                if (fare != null)
+                                    fares.add(fare);
+                            }
+                        }
+                    }
+                }
+
+                final Trip trip = new Trip(null, tripFrom, tripTo, legs, fares, null, null);
+                trips.add(trip);
+            }
+
+            final JsonContext context = new JsonContext(from, via, to, time, dep, products, res.optString("outCtxScrF"),
+                    res.optString("outCtxScrB"));
+            return new QueryTripsResult(header, null, from, null, to, context, trips);
+        } catch (final JSONException x) {
+            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
+        }
+    }
+
+    protected Fare parseJsonTripFare(final @Nullable String fareSetName, final @Nullable String fareSetDescription,
+            final String name, final Currency currency, final float price) {
+        if (name.endsWith("- Jahreskarte") || name.endsWith("- Monatskarte"))
+            return null;
+        if (name.startsWith("Vollpreis - "))
+            return new Fare(fareSetName, Fare.Type.ADULT, currency, price, name.substring(12), null);
+        if (name.startsWith("Kind - "))
+            return new Fare(fareSetName, Fare.Type.CHILD, currency, price, name.substring(7), null);
+        return null;
+    }
+
+    private String wrapJsonApiRequest(final String meth, final String req, final boolean formatted) {
+        return "{" //
+                + "\"auth\":" + checkNotNull(apiAuthorization) + "," //
+                + "\"client\":" + checkNotNull(apiClient) + "," //
+                + "\"ver\":\"" + checkNotNull(apiVersion) + "\",\"lang\":\"eng\"," //
+                + "\"svcReqL\":[{\"cfg\":{\"polyEnc\":\"GPA\"},\"meth\":\"" + meth + "\",\"req\":" + req + "}]," //
+                + "\"formatted\":" + formatted + "}";
+    }
+
+    private String jsonLocation(final Location location) {
+        if (location.type == LocationType.STATION && location.hasId())
+            return "{\"type\":\"S\",\"extId\":" + JSONObject.quote(location.id) + "}";
+        else if (location.type == LocationType.ADDRESS && location.hasId())
+            return "{\"type\":\"A\",\"lid\":" + JSONObject.quote(location.id) + "}";
+        else if (location.type == LocationType.POI && location.hasId())
+            return "{\"type\":\"P\",\"lid\":" + JSONObject.quote(location.id) + "}";
+        else
+            throw new IllegalArgumentException("cannot handle: " + location);
+    }
+
+    private CharSequence jsonDate(final Calendar time) {
+        final int year = time.get(Calendar.YEAR);
+        final int month = time.get(Calendar.MONTH) + 1;
+        final int day = time.get(Calendar.DAY_OF_MONTH);
+        return String.format(Locale.ENGLISH, "%04d%02d%02d", year, month, day);
+    }
+
+    private CharSequence jsonTime(final Calendar time) {
+        final int hour = time.get(Calendar.HOUR_OF_DAY);
+        final int minute = time.get(Calendar.MINUTE);
+        return String.format(Locale.ENGLISH, "%02d%02d00", hour, minute);
+    }
+
+    private static final Pattern P_JSON_TIME = Pattern.compile("(\\d{2})?(\\d{2})(\\d{2})(\\d{2})");
+
+    private final Date parseJsonTime(final Calendar calendar, final Date baseDate, final CharSequence str) {
+        if (str == null)
+            return null;
+
+        final Matcher m = P_JSON_TIME.matcher(str);
+        if (m.matches()) {
+            calendar.setTime(baseDate);
+
+            if (m.group(1) != null)
+                calendar.add(Calendar.DAY_OF_YEAR, Integer.parseInt(m.group(1)));
+            calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(m.group(2)));
+            calendar.set(Calendar.MINUTE, Integer.parseInt(m.group(3)));
+            calendar.set(Calendar.SECOND, Integer.parseInt(m.group(4)));
+
+            return calendar.getTime();
+        }
+
+        throw new RuntimeException("cannot parse: '" + str + "'");
+    }
+
+    private Stop parseJsonStop(final JSONObject json, final List<Location> locations, final Calendar c,
+            final Date baseDate) throws JSONException {
+        final Location location = locations.get(json.getInt("locX"));
+
+        final boolean arrivalCancelled = json.optBoolean("aCncl", false);
+        final Date plannedArrivalTime = parseJsonTime(c, baseDate, json.optString("aTimeS", null));
+        final Date predictedArrivalTime = parseJsonTime(c, baseDate, json.optString("aTimeR", null));
+        final Position plannedArrivalPosition = normalizePosition(json.optString("aPlatfS", null));
+        final Position predictedArrivalPosition = normalizePosition(json.optString("aPlatfR", null));
+
+        final boolean departureCancelled = json.optBoolean("dCncl", false);
+        final Date plannedDepartureTime = parseJsonTime(c, baseDate, json.optString("dTimeS", null));
+        final Date predictedDepartureTime = parseJsonTime(c, baseDate, json.optString("dTimeR", null));
+        final Position plannedDeparturePosition = normalizePosition(json.optString("dPlatfS", null));
+        final Position predictedDeparturePosition = normalizePosition(json.optString("dPlatfR", null));
+
+        return new Stop(location, plannedArrivalTime, predictedArrivalTime, plannedArrivalPosition,
+                predictedArrivalPosition, arrivalCancelled, plannedDepartureTime, predictedDepartureTime,
+                plannedDeparturePosition, predictedDeparturePosition, departureCancelled);
+    }
+
+    private List<String[]> parseRemList(final JSONArray remList) throws JSONException {
+        final List<String[]> remarks = new ArrayList<String[]>(remList.length());
+
+        for (int i = 0; i < remList.length(); i++) {
+            final JSONObject rem = remList.getJSONObject(i);
+            final String code = rem.getString("code");
+            final String txt = rem.getString("txtN");
+            remarks.add(new String[] { code, txt });
+        }
+
+        return remarks;
+    }
+
+    private List<Location> parseLocList(final JSONArray locList) throws JSONException {
+        final List<Location> locations = new ArrayList<Location>(locList.length());
+
+        for (int iLoc = 0; iLoc < locList.length(); iLoc++) {
+            final JSONObject loc = locList.getJSONObject(iLoc);
+            final String type = loc.getString("type");
+
+            final LocationType locationType;
+            final String id;
+            final String[] placeAndName;
+            final Set<Product> products;
+            if ("S".equals(type)) {
+                locationType = LocationType.STATION;
+                id = normalizeStationId(loc.getString("extId"));
+                placeAndName = splitStationName(loc.getString("name"));
+                final int pCls = loc.optInt("pCls", -1);
+                products = pCls != -1 ? intToProducts(pCls) : null;
+            } else if ("P".equals(type)) {
+                locationType = LocationType.POI;
+                id = loc.getString("lid");
+                placeAndName = splitPOI(loc.getString("name"));
+                products = null;
+            } else if ("A".equals(type)) {
+                locationType = LocationType.ADDRESS;
+                id = loc.getString("lid");
+                placeAndName = splitAddress(loc.getString("name"));
+                products = null;
+            } else {
+                throw new RuntimeException("Unknown type " + type + ": " + loc);
+            }
+
+            final JSONObject crd = loc.optJSONObject("crd");
+            if (crd != null)
+                locations.add(new Location(locationType, id, crd.getInt("y"), crd.getInt("x"), placeAndName[0],
+                        placeAndName[1], products));
+            else
+                locations.add(new Location(LocationType.STATION, id, null, placeAndName[0], placeAndName[1], products));
+        }
+
+        return locations;
+    }
+
+    private List<String> parseOpList(final JSONArray opList) throws JSONException {
+        final List<String> operators = new ArrayList<String>(opList.length());
+
+        for (int i = 0; i < opList.length(); i++) {
+            final JSONObject op = opList.getJSONObject(i);
+            final String operator = op.getString("name");
+            operators.add(operator);
+        }
+
+        return operators;
+    }
+
+    private List<Line> parseProdList(final JSONArray prodList, final List<String> operators) throws JSONException {
+        final List<Line> lines = new ArrayList<Line>(prodList.length());
+
+        for (int iProd = 0; iProd < prodList.length(); iProd++) {
+            final JSONObject prod = prodList.getJSONObject(iProd);
+            final int oprIndex = prod.optInt("oprX", -1);
+            final String operator = oprIndex != -1 ? operators.get(oprIndex) : null;
+            final int cls = prod.optInt("cls", -1);
+            final Product product = cls != -1 ? intToProduct(cls) : null;
+            final String name = prod.getString("name");
+            lines.add(newLine(operator, product, name));
+        }
+
+        return lines;
+    }
+
+    protected Line newLine(final String operator, final Product product, final String name) {
+        final String normalizedName;
+        if (product == Product.BUS && name.startsWith("Bus "))
+            normalizedName = name.substring(4);
+        else if (product == Product.TRAM && name.startsWith("Tram "))
+            normalizedName = name.substring(5);
+        else if (product == Product.SUBURBAN_TRAIN && name.startsWith("S "))
+            normalizedName = "S" + name.substring(2);
+        else
+            normalizedName = name;
+        return new Line(null, operator, product, normalizedName, lineStyle(operator, product, normalizedName));
+    }
+
+    @SuppressWarnings("serial")
+    public static class JsonContext implements QueryTripsContext {
+        public final Location from, via, to;
+        public final Date date;
+        public final boolean dep;
+        public final Set<Product> products;
+        public final String laterContext, earlierContext;
+
+        public JsonContext(final Location from, final @Nullable Location via, final Location to, final Date date,
+                final boolean dep, final Set<Product> products, final String laterContext,
+                final String earlierContext) {
+            this.from = from;
+            this.via = via;
+            this.to = to;
+            this.date = date;
+            this.dep = dep;
+            this.products = products;
+            this.laterContext = laterContext;
+            this.earlierContext = earlierContext;
+        }
+
+        @Override
+        public boolean canQueryLater() {
+            return laterContext != null;
+        }
+
+        @Override
+        public boolean canQueryEarlier() {
+            return earlierContext != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/enabler/src/de/schildbach/pte/AbstractHafasProvider.java b/enabler/src/de/schildbach/pte/AbstractHafasProvider.java
index 194bb6bd..3d5f22c5 100644
--- a/enabler/src/de/schildbach/pte/AbstractHafasProvider.java
+++ b/enabler/src/de/schildbach/pte/AbstractHafasProvider.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 the original author or authors.
+ * Copyright 2010-2017 the original author or authors.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,283 +21,37 @@ import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 
-import java.io.BufferedInputStream;
-import java.io.ByteArrayInputStream;
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.Currency;
-import java.util.Date;
 import java.util.EnumSet;
-import java.util.GregorianCalendar;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Locale;
-import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.zip.GZIPInputStream;
 
-import javax.annotation.Nullable;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-import org.xmlpull.v1.XmlPullParserFactory;
 
-import com.google.common.base.Charsets;
-import com.google.common.base.Joiner;
-import com.google.common.base.Strings;
-
-import de.schildbach.pte.dto.Departure;
-import de.schildbach.pte.dto.Fare;
-import de.schildbach.pte.dto.Line;
-import de.schildbach.pte.dto.Line.Attr;
 import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
-import de.schildbach.pte.dto.Point;
 import de.schildbach.pte.dto.Position;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
-import de.schildbach.pte.dto.ResultHeader;
 import de.schildbach.pte.dto.StationDepartures;
-import de.schildbach.pte.dto.Stop;
-import de.schildbach.pte.dto.SuggestLocationsResult;
-import de.schildbach.pte.dto.SuggestedLocation;
-import de.schildbach.pte.dto.Trip;
-import de.schildbach.pte.exception.ParserException;
-import de.schildbach.pte.exception.SessionExpiredException;
-import de.schildbach.pte.util.HttpClient;
-import de.schildbach.pte.util.LittleEndianDataInputStream;
-import de.schildbach.pte.util.ParserUtils;
-import de.schildbach.pte.util.StringReplaceReader;
-import de.schildbach.pte.util.XmlPullUtil;
-
-import okhttp3.HttpUrl;
-import okhttp3.ResponseBody;
 
 /**
  * @author Andreas Schildbach
  */
 public abstract class AbstractHafasProvider extends AbstractNetworkProvider {
-    protected final static String SERVER_PRODUCT = "hafas";
-    private static final String REQC_PROD = "hafas";
+    protected static final String SERVER_PRODUCT = "hafas";
     protected static final int DEFAULT_MAX_DEPARTURES = 100;
     protected static final int DEFAULT_MAX_LOCATIONS = 50;
 
-    protected HttpUrl stationBoardEndpoint;
-    protected HttpUrl getStopEndpoint;
-    protected HttpUrl queryEndpoint;
-    protected final HttpUrl mgateEndpoint;
-    private @Nullable HttpUrl extXmlEndpoint = null;
-    protected final String apiLanguage;
+    protected static final Logger log = LoggerFactory.getLogger(AbstractHafasProvider.class);
+
     private Product[] productsMap;
-    private @Nullable String accessId = null;
-    private @Nullable String clientType = "ANDROID";
-    private @Nullable String jsonApiVersion;
-    private @Nullable String jsonApiAuthorization;
-    private @Nullable String jsonApiClient;
-    private boolean jsonGetStopsUseWeight = true;
-    private Charset jsonNearbyLocationsEncoding = Charsets.ISO_8859_1;
-    private boolean dominantPlanStopTime = false;
-    private boolean useIso8601 = false;
-    private boolean stationBoardHasStationTable = true;
-    private boolean stationBoardHasLocation = false;
-    private boolean stationBoardCanDoEquivs = true;
 
-    private static final Logger log = LoggerFactory.getLogger(AbstractHafasProvider.class);
-
-    @SuppressWarnings("serial")
-    private static class Context implements QueryTripsContext {
-        public final String laterContext;
-        public final String earlierContext;
-        public final int sequence;
-
-        public Context(final String laterContext, final String earlierContext, final int sequence) {
-            this.laterContext = laterContext;
-            this.earlierContext = earlierContext;
-            this.sequence = sequence;
-        }
-
-        @Override
-        public boolean canQueryLater() {
-            return laterContext != null;
-        }
-
-        @Override
-        public boolean canQueryEarlier() {
-            return earlierContext != null;
-        }
-    }
-
-    @SuppressWarnings("serial")
-    public static class JsonContext implements QueryTripsContext {
-        public final Location from, via, to;
-        public final Date date;
-        public final boolean dep;
-        public final Set<Product> products;
-        public final String laterContext, earlierContext;
-
-        public JsonContext(final Location from, final @Nullable Location via, final Location to, final Date date,
-                final boolean dep, final Set<Product> products, final String laterContext,
-                final String earlierContext) {
-            this.from = from;
-            this.via = via;
-            this.to = to;
-            this.date = date;
-            this.dep = dep;
-            this.products = products;
-            this.laterContext = laterContext;
-            this.earlierContext = earlierContext;
-        }
-
-        @Override
-        public boolean canQueryLater() {
-            return laterContext != null;
-        }
-
-        @Override
-        public boolean canQueryEarlier() {
-            return earlierContext != null;
-        }
-    }
-
-    @SuppressWarnings("serial")
-    public static class QueryTripsBinaryContext implements QueryTripsContext {
-        public final String ident;
-        public final int seqNr;
-        public final String ld;
-        public final int usedBufferSize;
-        private final boolean canQueryMore;
-
-        public QueryTripsBinaryContext(final String ident, final int seqNr, final String ld, final int usedBufferSize,
-                final boolean canQueryMore) {
-            this.ident = ident;
-            this.seqNr = seqNr;
-            this.ld = ld;
-            this.usedBufferSize = usedBufferSize;
-            this.canQueryMore = canQueryMore;
-        }
-
-        @Override
-        public boolean canQueryLater() {
-            return canQueryMore;
-        }
-
-        @Override
-        public boolean canQueryEarlier() {
-            return canQueryMore;
-        }
-    }
-
-    public AbstractHafasProvider(final NetworkId network, final HttpUrl apiBase, final String apiLanguage,
-            final Product[] productsMap) {
+    protected AbstractHafasProvider(final NetworkId network, final Product[] productsMap) {
         super(network);
-        this.stationBoardEndpoint = apiBase.newBuilder().addPathSegment("stboard.exe").build();
-        this.getStopEndpoint = apiBase.newBuilder().addPathSegment("ajax-getstop.exe").build();
-        this.queryEndpoint = apiBase.newBuilder().addPathSegment("query.exe").build();
-        this.mgateEndpoint = apiBase.newBuilder().addPathSegment("mgate.exe").build();
-        this.apiLanguage = apiLanguage;
         this.productsMap = productsMap;
     }
 
-    protected AbstractHafasProvider setStationBoardEndpoint(final HttpUrl stationBoardEndpoint) {
-        this.stationBoardEndpoint = stationBoardEndpoint;
-        return this;
-    }
-
-    protected AbstractHafasProvider setGetStopEndpoint(final HttpUrl getStopEndpoint) {
-        this.getStopEndpoint = getStopEndpoint;
-        return this;
-    }
-
-    protected AbstractHafasProvider setQueryEndpoint(final HttpUrl queryEndpoint) {
-        this.queryEndpoint = queryEndpoint;
-        return this;
-    }
-
-    protected AbstractHafasProvider setExtXmlEndpoint(final HttpUrl extXmlEndpoint) {
-        this.extXmlEndpoint = extXmlEndpoint;
-        return this;
-    }
-
-    protected AbstractHafasProvider setAccessId(final String accessId) {
-        this.accessId = accessId;
-        return this;
-    }
-
-    protected AbstractHafasProvider setClientType(final String clientType) {
-        this.clientType = clientType;
-        return this;
-    }
-
-    protected AbstractHafasProvider setJsonApiVersion(final String jsonApiVersion) {
-        this.jsonApiVersion = jsonApiVersion;
-        return this;
-    }
-
-    protected AbstractHafasProvider setJsonApiAuthorization(final String jsonApiAuthorization) {
-        this.jsonApiAuthorization = jsonApiAuthorization;
-        return this;
-    }
-
-    protected AbstractHafasProvider setJsonApiClient(final String jsonApiClient) {
-        this.jsonApiClient = jsonApiClient;
-        return this;
-    }
-
-    protected AbstractHafasProvider setDominantPlanStopTime(final boolean dominantPlanStopTime) {
-        this.dominantPlanStopTime = dominantPlanStopTime;
-        return this;
-    }
-
-    protected AbstractHafasProvider setJsonGetStopsUseWeight(final boolean jsonGetStopsUseWeight) {
-        this.jsonGetStopsUseWeight = jsonGetStopsUseWeight;
-        return this;
-    }
-
-    protected AbstractHafasProvider setJsonNearbyLocationsEncoding(final Charset jsonNearbyLocationsEncoding) {
-        this.jsonNearbyLocationsEncoding = jsonNearbyLocationsEncoding;
-        return this;
-    }
-
-    protected AbstractHafasProvider setUseIso8601(final boolean useIso8601) {
-        this.useIso8601 = useIso8601;
-        return this;
-    }
-
-    protected AbstractHafasProvider setStationBoardHasStationTable(final boolean stationBoardHasStationTable) {
-        this.stationBoardHasStationTable = stationBoardHasStationTable;
-        return this;
-    }
-
-    protected AbstractHafasProvider setStationBoardHasLocation(final boolean stationBoardHasLocation) {
-        this.stationBoardHasLocation = stationBoardHasLocation;
-        return this;
-    }
-
-    protected AbstractHafasProvider setStationBoardCanDoEquivs(final boolean canDoEquivs) {
-        this.stationBoardCanDoEquivs = canDoEquivs;
-        return this;
-    }
-
     @Override
     protected boolean hasCapability(final Capability capability) {
         return true;
@@ -381,2550 +135,9 @@ public abstract class AbstractHafasProvider extends AbstractNetworkProvider {
         return new String[] { null, address };
     }
 
-    private final String wrapReqC(final CharSequence request, final Charset encoding) {
-        return "<?xml version=\"1.0\" encoding=\"" + (encoding != null ? encoding.name() : "iso-8859-1") + "\"?>" //
-                + "<ReqC ver=\"1.1\" prod=\"" + REQC_PROD + "\" lang=\"DE\""
-                + (accessId != null ? " accessId=\"" + accessId + "\"" : "") + ">" //
-                + request //
-                + "</ReqC>";
-    }
-
-    private final Location parseStation(final XmlPullParser pp) {
-        final String type = pp.getName();
-        if ("Station".equals(type)) {
-            final String name = XmlPullUtil.attr(pp, "name");
-            final String id = XmlPullUtil.attr(pp, "externalStationNr");
-            final int x = XmlPullUtil.intAttr(pp, "x");
-            final int y = XmlPullUtil.intAttr(pp, "y");
-
-            final String[] placeAndName = splitStationName(name);
-            return new Location(LocationType.STATION, id, y, x, placeAndName[0], placeAndName[1]);
-        }
-        throw new IllegalStateException("cannot handle: " + type);
-    }
-
-    private static final Location parsePoi(final XmlPullParser pp) {
-        final String type = pp.getName();
-        if ("Poi".equals(type)) {
-            String name = XmlPullUtil.attr(pp, "name");
-            if (name.equals("unknown"))
-                name = null;
-            final int x = XmlPullUtil.intAttr(pp, "x");
-            final int y = XmlPullUtil.intAttr(pp, "y");
-            return new Location(LocationType.POI, null, y, x, null, name);
-        }
-        throw new IllegalStateException("cannot handle: " + type);
-    }
-
-    private final Location parseAddress(final XmlPullParser pp) {
-        final String type = pp.getName();
-        if ("Address".equals(type)) {
-            String name = XmlPullUtil.attr(pp, "name");
-            if (name.equals("unknown"))
-                name = null;
-            final int x = XmlPullUtil.intAttr(pp, "x");
-            final int y = XmlPullUtil.intAttr(pp, "y");
-
-            final String[] placeAndName = splitAddress(name);
-            return new Location(LocationType.ADDRESS, null, y, x, placeAndName[0], placeAndName[1]);
-        }
-        throw new IllegalStateException("cannot handle: " + type);
-    }
-
-    private final Position parsePlatform(final XmlPullParser pp) throws XmlPullParserException, IOException {
-        XmlPullUtil.enter(pp, "Platform");
-        final String platformText = XmlPullUtil.valueTag(pp, "Text");
-        XmlPullUtil.skipExit(pp, "Platform");
-
-        if (platformText == null || platformText.length() == 0)
-            return null;
-        else
-            return parsePosition(platformText);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        final HttpUrl.Builder url = getStopEndpoint.newBuilder().addPathSegment(apiLanguage);
-        appendJsonGetStopsParameters(url, checkNotNull(constraint), 0);
-        return jsonGetStops(url.build());
-    }
-
-    protected void appendJsonGetStopsParameters(final HttpUrl.Builder url, final CharSequence constraint,
-            final int maxStops) {
-        url.addQueryParameter("getstop", "1");
-        url.addQueryParameter("REQ0JourneyStopsS0A", "255");
-        url.addEncodedQueryParameter("REQ0JourneyStopsS0G",
-                ParserUtils.urlEncode(constraint.toString() + "?", requestUrlEncoding));
-        if (maxStops > 0)
-            url.addQueryParameter("REQ0JourneyStopsB", Integer.toString(maxStops));
-        url.addQueryParameter("js", "true");
-    }
-
-    private static final Pattern P_AJAX_GET_STOPS_JSON = Pattern
-            .compile("SLs\\.sls\\s*=\\s*(.*?);\\s*SLs\\.showSuggestion\\(\\);", Pattern.DOTALL);
-    private static final Pattern P_AJAX_GET_STOPS_ID = Pattern.compile(".*?@L=0*(\\d+)@.*?");
-
-    protected final SuggestLocationsResult jsonGetStops(final HttpUrl url) throws IOException {
-        final CharSequence page = httpClient.get(url);
-
-        final Matcher mJson = P_AJAX_GET_STOPS_JSON.matcher(page);
-        if (mJson.matches()) {
-            final String json = mJson.group(1);
-            final List<SuggestedLocation> locations = new ArrayList<SuggestedLocation>();
-
-            try {
-                final JSONObject head = new JSONObject(json);
-                final JSONArray aSuggestions = head.getJSONArray("suggestions");
-
-                for (int i = 0; i < aSuggestions.length(); i++) {
-                    final JSONObject suggestion = aSuggestions.optJSONObject(i);
-                    if (suggestion != null) {
-                        final int type = suggestion.getInt("type");
-                        final String value = suggestion.getString("value");
-                        final int lat = suggestion.optInt("ycoord");
-                        final int lon = suggestion.optInt("xcoord");
-                        final int weight = jsonGetStopsUseWeight ? suggestion.getInt("weight") : -i;
-                        String localId = null;
-                        final Matcher m = P_AJAX_GET_STOPS_ID.matcher(suggestion.getString("id"));
-                        if (m.matches())
-                            localId = m.group(1);
-
-                        final Location location;
-
-                        if (type == 1) // station
-                        {
-                            final String[] placeAndName = splitStationName(value);
-                            location = new Location(LocationType.STATION, localId, lat, lon, placeAndName[0],
-                                    placeAndName[1]);
-                        } else if (type == 2) // address
-                        {
-                            final String[] placeAndName = splitAddress(value);
-                            location = new Location(LocationType.ADDRESS, null, lat, lon, placeAndName[0],
-                                    placeAndName[1]);
-                        } else if (type == 4) // poi
-                        {
-                            final String[] placeAndName = splitPOI(value);
-                            location = new Location(LocationType.POI, localId, lat, lon, placeAndName[0],
-                                    placeAndName[1]);
-                        } else if (type == 128) // crossing
-                        {
-                            final String[] placeAndName = splitAddress(value);
-                            location = new Location(LocationType.ADDRESS, localId, lat, lon, placeAndName[0],
-                                    placeAndName[1]);
-                        } else if (type == 87) {
-                            location = null;
-                            // don't know what to do
-                        } else {
-                            throw new IllegalStateException("unknown type " + type + " on " + url);
-                        }
-
-                        if (location != null) {
-                            final SuggestedLocation suggestedLocation = new SuggestedLocation(location, weight);
-                            locations.add(suggestedLocation);
-                        }
-                    }
-                }
-
-                return new SuggestLocationsResult(new ResultHeader(network, SERVER_PRODUCT), locations);
-            } catch (final JSONException x) {
-                throw new RuntimeException("cannot parse: '" + json + "' on " + url, x);
-            }
-        } else {
-            throw new RuntimeException("cannot parse: '" + page + "' on " + url);
-        }
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        checkNotNull(Strings.emptyToNull(stationId));
-
-        final HttpUrl.Builder url = stationBoardEndpoint.newBuilder().addPathSegment(apiLanguage);
-        appendXmlStationBoardParameters(url, time, stationId, maxDepartures, equivs, "vs_java3");
-        return xmlStationBoard(url.build(), stationId);
-    }
-
-    protected void appendXmlStationBoardParameters(final HttpUrl.Builder url, final @Nullable Date time,
-            final String stationId, final int maxDepartures, final boolean equivs, final @Nullable String styleSheet) {
-        url.addQueryParameter("productsFilter", allProductsString().toString());
-        url.addQueryParameter("boardType", "dep");
-        if (stationBoardCanDoEquivs)
-            url.addQueryParameter("disableEquivs", equivs ? "0" : "1");
-        url.addQueryParameter("maxJourneys",
-                Integer.toString(maxDepartures > 0 ? maxDepartures : DEFAULT_MAX_DEPARTURES));
-        url.addEncodedQueryParameter("input", ParserUtils.urlEncode(normalizeStationId(stationId), requestUrlEncoding));
-        appendDateTimeParameters(url, time, "date", "time");
-        if (clientType != null)
-            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
-        if (styleSheet != null)
-            url.addQueryParameter("L", styleSheet);
-        url.addQueryParameter("hcount", "0"); // prevents showing old departures
-        url.addQueryParameter("start", "yes");
-    }
-
-    protected void appendDateTimeParameters(final HttpUrl.Builder url, final Date time, final String dateParamName,
-            final String timeParamName) {
-        final Calendar c = new GregorianCalendar(timeZone);
-        c.setTime(time);
-        final int year = c.get(Calendar.YEAR);
-        final int month = c.get(Calendar.MONTH) + 1;
-        final int day = c.get(Calendar.DAY_OF_MONTH);
-        final int hour = c.get(Calendar.HOUR_OF_DAY);
-        final int minute = c.get(Calendar.MINUTE);
-        url.addEncodedQueryParameter(dateParamName,
-                ParserUtils.urlEncode(
-                        useIso8601 ? String.format(Locale.ENGLISH, "%04d-%02d-%02d", year, month, day)
-                                : String.format(Locale.ENGLISH, "%02d.%02d.%02d", day, month, year - 2000),
-                        requestUrlEncoding));
-        url.addEncodedQueryParameter(timeParamName,
-                ParserUtils.urlEncode(String.format(Locale.ENGLISH, "%02d:%02d", hour, minute), requestUrlEncoding));
-    }
-
-    private static final Pattern P_XML_STATION_BOARD_DELAY = Pattern.compile("(?:-|k\\.A\\.?|cancel|([+-]?\\s*\\d+))");
-
-    protected final QueryDeparturesResult xmlStationBoard(final HttpUrl url, final String stationId)
-            throws IOException {
-        final String normalizedStationId = normalizeStationId(stationId);
-        final AtomicReference<QueryDeparturesResult> result = new AtomicReference<QueryDeparturesResult>();
-
-        httpClient.getInputStream(new HttpClient.Callback() {
-
-            @Override
-            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
-                StringReplaceReader reader = null;
-                String firstChars = null;
-
-                // work around unparsable XML
-                reader = new StringReplaceReader(body.charStream(), " & ", " &amp; ");
-                reader.replace("<b>", " ");
-                reader.replace("</b>", " ");
-                reader.replace("<u>", " ");
-                reader.replace("</u>", " ");
-                reader.replace("<i>", " ");
-                reader.replace("</i>", " ");
-                reader.replace("<br />", " ");
-                reader.replace(" ->", " &#x2192;"); // right arrow
-                reader.replace(" <-", " &#x2190;"); // left arrow
-                reader.replace(" <> ", " &#x2194; "); // left-right arrow
-                addCustomReplaces(reader);
-
-                try {
-                    final XmlPullParserFactory factory = XmlPullParserFactory
-                            .newInstance(System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
-                    final XmlPullParser pp = factory.newPullParser();
-                    pp.setInput(reader);
-
-                    pp.nextTag();
-
-                    final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-                    final QueryDeparturesResult r = new QueryDeparturesResult(header);
-
-                    if (XmlPullUtil.test(pp, "Err")) {
-                        final String code = XmlPullUtil.attr(pp, "code");
-                        final String text = XmlPullUtil.attr(pp, "text");
-
-                        if (code.equals("H730")) {
-                            result.set(new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION));
-                            return;
-                        }
-                        if (code.equals("H890")) {
-                            r.stationDepartures
-                                    .add(new StationDepartures(new Location(LocationType.STATION, normalizedStationId),
-                                            Collections.<Departure> emptyList(), null));
-                            result.set(r);
-                            return;
-                        }
-                        throw new IllegalArgumentException("unknown error " + code + ", " + text);
-                    }
-
-                    String[] stationPlaceAndName = null;
-
-                    if (stationBoardHasStationTable)
-                        XmlPullUtil.enter(pp, "StationTable");
-                    else
-                        checkState(!XmlPullUtil.test(pp, "StationTable"));
-
-                    if (stationBoardHasLocation) {
-                        XmlPullUtil.require(pp, "St");
-
-                        final String evaId = XmlPullUtil.attr(pp, "evaId");
-                        if (evaId != null) {
-                            if (!evaId.equals(normalizedStationId))
-                                throw new IllegalStateException(
-                                        "stationId: " + normalizedStationId + ", evaId: " + evaId);
-
-                            final String name = XmlPullUtil.attr(pp, "name");
-                            if (name != null)
-                                stationPlaceAndName = splitStationName(name.trim());
-                        }
-                        XmlPullUtil.requireSkip(pp, "St");
-                    } else {
-                        checkState(!XmlPullUtil.test(pp, "St"));
-                    }
-
-                    while (XmlPullUtil.test(pp, "Journey")) {
-                        final String fpTime = XmlPullUtil.attr(pp, "fpTime");
-                        final String fpDate = XmlPullUtil.attr(pp, "fpDate");
-                        final String delay = XmlPullUtil.attr(pp, "delay");
-                        final String eDelay = XmlPullUtil.optAttr(pp, "e_delay", null);
-                        final String platform = XmlPullUtil.optAttr(pp, "platform", null);
-                        // TODO newpl
-                        final String targetLoc = XmlPullUtil.optAttr(pp, "targetLoc", null);
-                        // TODO hafasname
-                        final String dirnr = XmlPullUtil.optAttr(pp, "dirnr", null);
-                        final String prod = XmlPullUtil.attr(pp, "prod");
-                        final String classStr = XmlPullUtil.optAttr(pp, "class", null);
-                        final String dir = XmlPullUtil.optAttr(pp, "dir", null);
-                        final String capacityStr = XmlPullUtil.optAttr(pp, "capacity", null);
-                        final String depStation = XmlPullUtil.optAttr(pp, "depStation", null);
-                        final String delayReason = XmlPullUtil.optAttr(pp, "delayReason", null);
-                        // TODO is_reachable
-                        // TODO disableTrainInfo
-                        // TODO lineFG/lineBG (ZVV)
-                        final String administration = normalizeLineAdministration(
-                                XmlPullUtil.optAttr(pp, "administration", null));
-
-                        if (!"cancel".equals(delay) && !"cancel".equals(eDelay)) {
-                            final Calendar plannedTime = new GregorianCalendar(timeZone);
-                            plannedTime.clear();
-                            ParserUtils.parseEuropeanTime(plannedTime, fpTime);
-                            if (fpDate.length() == 8)
-                                ParserUtils.parseGermanDate(plannedTime, fpDate);
-                            else if (fpDate.length() == 10)
-                                ParserUtils.parseIsoDate(plannedTime, fpDate);
-                            else
-                                throw new IllegalStateException("cannot parse: '" + fpDate + "'");
-
-                            final Calendar predictedTime;
-                            if (eDelay != null) {
-                                predictedTime = new GregorianCalendar(timeZone);
-                                predictedTime.setTimeInMillis(plannedTime.getTimeInMillis());
-                                predictedTime.add(Calendar.MINUTE, Integer.parseInt(eDelay));
-                            } else if (delay != null) {
-                                final Matcher m = P_XML_STATION_BOARD_DELAY.matcher(delay);
-                                if (m.matches()) {
-                                    if (m.group(1) != null) {
-                                        predictedTime = new GregorianCalendar(timeZone);
-                                        predictedTime.setTimeInMillis(plannedTime.getTimeInMillis());
-                                        predictedTime.add(Calendar.MINUTE, Integer.parseInt(m.group(1)));
-                                    } else {
-                                        predictedTime = null;
-                                    }
-                                } else {
-                                    throw new RuntimeException("cannot parse delay: '" + delay + "'");
-                                }
-                            } else {
-                                predictedTime = null;
-                            }
-
-                            final Position position = parsePosition(ParserUtils.resolveEntities(platform));
-
-                            final String destinationName;
-                            if (dir != null)
-                                destinationName = dir.trim();
-                            else if (targetLoc != null)
-                                destinationName = targetLoc.trim();
-                            else
-                                destinationName = null;
-
-                            final Location destination;
-                            if (dirnr != null) {
-                                final String[] destinationPlaceAndName = splitStationName(destinationName);
-                                destination = new Location(LocationType.STATION, dirnr, destinationPlaceAndName[0],
-                                        destinationPlaceAndName[1]);
-                            } else {
-                                destination = new Location(LocationType.ANY, null, null, destinationName);
-                            }
-
-                            final Line prodLine = parseLineAndType(prod);
-                            final Line line;
-                            if (classStr != null) {
-                                final Product product = intToProduct(Integer.parseInt(classStr));
-                                if (product == null)
-                                    throw new IllegalArgumentException();
-                                // could check for type consistency here
-                                final Set<Attr> attrs = prodLine.attrs;
-                                if (attrs != null)
-                                    line = newLine(administration, product, prodLine.label, null,
-                                            attrs.toArray(new Line.Attr[0]));
-                                else
-                                    line = newLine(administration, product, prodLine.label, null);
-                            } else {
-                                final Set<Attr> attrs = prodLine.attrs;
-                                if (attrs != null)
-                                    line = newLine(administration, prodLine.product, prodLine.label, null,
-                                            attrs.toArray(new Line.Attr[0]));
-                                else
-                                    line = newLine(administration, prodLine.product, prodLine.label, null);
-                            }
-
-                            final int[] capacity;
-                            if (capacityStr != null && !"0|0".equals(capacityStr)) {
-                                final String[] capacityParts = capacityStr.split("\\|");
-                                capacity = new int[] { Integer.parseInt(capacityParts[0]),
-                                        Integer.parseInt(capacityParts[1]) };
-                            } else {
-                                capacity = null;
-                            }
-
-                            final String message;
-                            if (delayReason != null) {
-                                final String msg = delayReason.trim();
-                                message = msg.length() > 0 ? msg : null;
-                            } else {
-                                message = null;
-                            }
-
-                            final Departure departure = new Departure(plannedTime.getTime(),
-                                    predictedTime != null ? predictedTime.getTime() : null, line, position, destination,
-                                    capacity, message);
-
-                            final Location location;
-                            if (!stationBoardCanDoEquivs || depStation == null) {
-                                location = new Location(LocationType.STATION, normalizedStationId,
-                                        stationPlaceAndName != null ? stationPlaceAndName[0] : null,
-                                        stationPlaceAndName != null ? stationPlaceAndName[1] : null);
-                            } else {
-                                final String[] depPlaceAndName = splitStationName(depStation);
-                                location = new Location(LocationType.STATION, null, depPlaceAndName[0],
-                                        depPlaceAndName[1]);
-                            }
-
-                            StationDepartures stationDepartures = findStationDepartures(r.stationDepartures, location);
-                            if (stationDepartures == null) {
-                                stationDepartures = new StationDepartures(location, new ArrayList<Departure>(8), null);
-                                r.stationDepartures.add(stationDepartures);
-                            }
-
-                            stationDepartures.departures.add(departure);
-                        }
-
-                        XmlPullUtil.requireSkip(pp, "Journey");
-                    }
-
-                    if (stationBoardHasStationTable)
-                        XmlPullUtil.exit(pp, "StationTable");
-
-                    XmlPullUtil.requireEndDocument(pp);
-
-                    // sort departures
-                    for (final StationDepartures stationDepartures : r.stationDepartures)
-                        Collections.sort(stationDepartures.departures, Departure.TIME_COMPARATOR);
-
-                    result.set(r);
-                } catch (final XmlPullParserException x) {
-                    throw new ParserException("cannot parse xml: " + firstChars, x);
-                }
-            }
-        }, url);
-
-        return result.get();
-    }
-
-    private StationDepartures findStationDepartures(final List<StationDepartures> stationDepartures,
-            final Location location) {
-        for (final StationDepartures stationDeparture : stationDepartures)
-            if (stationDeparture.location.equals(location))
-                return stationDeparture;
-
-        return null;
-    }
-
-    protected void addCustomReplaces(final StringReplaceReader reader) {
-    }
-
-    protected final NearbyLocationsResult jsonLocGeoPos(final EnumSet<LocationType> types, final int lat, final int lon)
-            throws IOException {
-        final boolean getPOIs = types.contains(LocationType.POI);
-        final String request = wrapJsonApiRequest("LocGeoPos",
-                "{\"ring\":" //
-                        + "{\"cCrd\":{\"x\":" + lon + ",\"y\":" + lat + "}}," //
-                        + "\"getPOIs\":" + getPOIs + "}", //
-                false);
-
-        final HttpUrl url = checkNotNull(mgateEndpoint);
-        final CharSequence page = httpClient.get(url, request, "application/json");
-
-        try {
-            final JSONObject head = new JSONObject(page.toString());
-            final String headErr = head.optString("err", null);
-            if (headErr != null)
-                throw new RuntimeException(headErr);
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
-
-            final JSONArray svcResList = head.getJSONArray("svcResL");
-            checkState(svcResList.length() == 1);
-            final JSONObject svcRes = svcResList.optJSONObject(0);
-            checkState("LocGeoPos".equals(svcRes.getString("meth")));
-            final String err = svcRes.getString("err");
-            if (!"OK".equals(err)) {
-                final String errTxt = svcRes.getString("errTxt");
-                throw new RuntimeException(err + " " + errTxt);
-            }
-            final JSONObject res = svcRes.getJSONObject("res");
-
-            final JSONObject common = res.getJSONObject("common");
-            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
-
-            final JSONArray locL = res.optJSONArray("locL");
-            final List<Location> locations;
-            if (locL != null) {
-                locations = parseLocList(locL);
-
-                // filter unwanted location types
-                for (Iterator<Location> i = locations.iterator(); i.hasNext();) {
-                    final Location location = i.next();
-                    if (!types.contains(location.type))
-                        i.remove();
-                }
-            } else {
-                locations = Collections.emptyList();
-            }
-
-            return new NearbyLocationsResult(header, locations);
-        } catch (final JSONException x) {
-            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
-        }
-    }
-
-    protected final QueryDeparturesResult jsonStationBoard(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        final Calendar c = new GregorianCalendar(timeZone);
-        c.setTime(time);
-        final CharSequence jsonDate = jsonDate(c);
-        final CharSequence jsonTime = jsonTime(c);
-        final CharSequence normalizedStationId = normalizeStationId(stationId);
-        final CharSequence stbFltrEquiv = Boolean.toString(!equivs);
-        final CharSequence maxJny = Integer.toString(maxDepartures != 0 ? maxDepartures : DEFAULT_MAX_DEPARTURES);
-        final CharSequence getPasslist = Boolean.toString(true); // traffic expensive
-        final String request = wrapJsonApiRequest("StationBoard",
-                "{\"type\":\"DEP\"," //
-                        + "\"date\":\"" + jsonDate + "\"," //
-                        + "\"time\":\"" + jsonTime + "\"," //
-                        + "\"stbLoc\":{\"type\":\"S\"," + "\"state\":\"F\"," // F/M
-                        + "\"extId\":" + JSONObject.quote(normalizedStationId.toString()) + "}," //
-                        + "\"stbFltrEquiv\":" + stbFltrEquiv + ",\"maxJny\":" + maxJny + ",\"getPasslist\":"
-                        + getPasslist + "}",
-                false);
-
-        final HttpUrl url = checkNotNull(mgateEndpoint);
-        final CharSequence page = httpClient.get(url, request, "application/json");
-
-        try {
-            final JSONObject head = new JSONObject(page.toString());
-            final String headErr = head.optString("err", null);
-            if (headErr != null)
-                throw new RuntimeException(headErr);
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
-            final QueryDeparturesResult result = new QueryDeparturesResult(header);
-
-            final JSONArray svcResList = head.getJSONArray("svcResL");
-            checkState(svcResList.length() == 1);
-            final JSONObject svcRes = svcResList.optJSONObject(0);
-            checkState("StationBoard".equals(svcRes.getString("meth")));
-            final String err = svcRes.getString("err");
-            if (!"OK".equals(err)) {
-                final String errTxt = svcRes.getString("errTxt");
-                log.debug("Hafas error: {} {}", err, errTxt);
-                if ("LOCATION".equals(err) && "HCI Service: location missing or invalid".equals(errTxt))
-                    return new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION);
-                if ("FAIL".equals(err) && "HCI Service: request failed".equals(errTxt))
-                    return new QueryDeparturesResult(header, QueryDeparturesResult.Status.SERVICE_DOWN);
-                throw new RuntimeException(err + " " + errTxt);
-            } else if ("1.10".equals(jsonApiVersion) && svcRes.toString().length() == 170) {
-                // horrible hack, because API version 1.10 doesn't signal invalid stations via error
-                return new QueryDeparturesResult(header, QueryDeparturesResult.Status.INVALID_STATION);
-            }
-            final JSONObject res = svcRes.getJSONObject("res");
-
-            final JSONObject common = res.getJSONObject("common");
-            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
-            final List<String> operators = parseOpList(common.getJSONArray("opL"));
-            final List<Line> lines = parseProdList(common.getJSONArray("prodL"), operators);
-            final JSONArray locList = common.getJSONArray("locL");
-            final List<Location> locations = parseLocList(locList);
-
-            final JSONArray jnyList = res.optJSONArray("jnyL");
-            if (jnyList != null) {
-                for (int iJny = 0; iJny < jnyList.length(); iJny++) {
-                    final JSONObject jny = jnyList.getJSONObject(iJny);
-                    final JSONObject stbStop = jny.getJSONObject("stbStop");
-
-                    final String stbStopPlatformS = stbStop.optString("dPlatfS", null);
-                    c.clear();
-                    ParserUtils.parseIsoDate(c, jny.getString("date"));
-                    final Date baseDate = c.getTime();
-
-                    final Date plannedTime = parseJsonTime(c, baseDate, stbStop.getString("dTimeS"));
-
-                    final Date predictedTime = parseJsonTime(c, baseDate, stbStop.optString("dTimeR", null));
-
-                    final Line line = lines.get(stbStop.getInt("dProdX"));
-
-                    final Location location = equivs ? locations.get(stbStop.getInt("locX"))
-                            : new Location(LocationType.STATION, stationId);
-                    final Position position = normalizePosition(stbStopPlatformS);
-
-                    final String jnyDirTxt = jny.getString("dirTxt");
-                    final JSONArray stopList = jny.optJSONArray("stopL");
-                    final Location destination;
-                    if (stopList != null) {
-                        final int lastStopIdx = stopList.getJSONObject(stopList.length() - 1).getInt("locX");
-                        final String lastStopName = locList.getJSONObject(lastStopIdx).getString("name");
-                        if (jnyDirTxt.equals(lastStopName))
-                            destination = locations.get(lastStopIdx);
-                        else
-                            destination = new Location(LocationType.ANY, null, null, jnyDirTxt);
-                    } else {
-                        destination = new Location(LocationType.ANY, null, null, jnyDirTxt);
-                    }
-
-                    final Departure departure = new Departure(plannedTime, predictedTime, line, position, destination,
-                            null, null);
-
-                    StationDepartures stationDepartures = findStationDepartures(result.stationDepartures, location);
-                    if (stationDepartures == null) {
-                        stationDepartures = new StationDepartures(location, new ArrayList<Departure>(8), null);
-                        result.stationDepartures.add(stationDepartures);
-                    }
-
-                    stationDepartures.departures.add(departure);
-                }
-            }
-
-            // sort departures
-            for (final StationDepartures stationDepartures : result.stationDepartures)
-                Collections.sort(stationDepartures.departures, Departure.TIME_COMPARATOR);
-
-            return result;
-        } catch (final JSONException x) {
-            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
-        }
-    }
-
-    protected final SuggestLocationsResult jsonLocMatch(final CharSequence constraint) throws IOException {
-        final String request = wrapJsonApiRequest("LocMatch",
-                "{\"input\":{\"field\":\"S\",\"loc\":{\"name\":" + JSONObject.quote(checkNotNull(constraint).toString())
-                        + ",\"meta\":false},\"maxLoc\":" + DEFAULT_MAX_LOCATIONS + "}}",
-                true);
-
-        final HttpUrl url = checkNotNull(mgateEndpoint);
-        final CharSequence page = httpClient.get(url, request, "application/json");
-
-        try {
-            final JSONObject head = new JSONObject(page.toString());
-            final String headErr = head.optString("err", null);
-            if (headErr != null)
-                throw new RuntimeException(headErr);
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
-
-            final JSONArray svcResList = head.getJSONArray("svcResL");
-            checkState(svcResList.length() == 1);
-            final JSONObject svcRes = svcResList.optJSONObject(0);
-            checkState("LocMatch".equals(svcRes.getString("meth")));
-            final String err = svcRes.getString("err");
-            if (!"OK".equals(err)) {
-                final String errTxt = svcRes.getString("errTxt");
-                throw new RuntimeException(err + " " + errTxt);
-            }
-            final JSONObject res = svcRes.getJSONObject("res");
-
-            final JSONObject common = res.getJSONObject("common");
-            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
-
-            final JSONObject match = res.getJSONObject("match");
-            final List<Location> locations = parseLocList(match.optJSONArray("locL"));
-            final List<SuggestedLocation> suggestedLocations = new ArrayList<SuggestedLocation>(locations.size());
-            for (final Location location : locations)
-                suggestedLocations.add(new SuggestedLocation(location));
-            // TODO weight
-
-            return new SuggestLocationsResult(header, suggestedLocations);
-        } catch (final JSONException x) {
-            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
-        }
-    }
-
-    private static final Joiner JOINER = Joiner.on(' ').skipNulls();
-
-    protected final QueryTripsResult jsonTripSearch(Location from, @Nullable Location via, Location to, final Date time,
-            final boolean dep, final @Nullable Set<Product> products, final String moreContext) throws IOException {
-        if (!from.hasId() && from.hasName()) {
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-            final List<Location> locations = suggestLocations(JOINER.join(from.place, from.name)).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM);
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, locations, null, null);
-            from = locations.get(0);
-        }
-
-        if (via != null && !via.hasId() && via.hasName()) {
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-            final List<Location> locations = suggestLocations(JOINER.join(via.place, via.name)).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA);
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, locations, null, null);
-            via = locations.get(0);
-        }
-
-        if (!to.hasId() && to.hasName()) {
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-            final List<Location> locations = suggestLocations(JOINER.join(to.place, to.name)).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO);
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, null, null, locations);
-            to = locations.get(0);
-        }
-
-        final Calendar c = new GregorianCalendar(timeZone);
-        c.setTime(time);
-        final CharSequence outDate = jsonDate(c);
-        final CharSequence outTime = jsonTime(c);
-        final CharSequence outFrwdKey = "1.11".equals(jsonApiVersion) ? "outFrwd" : "frwd";
-        final CharSequence outFrwd = Boolean.toString(dep);
-        final CharSequence jnyFltr = productsString(products);
-        final CharSequence jsonContext = moreContext != null ? "\"ctxScr\":" + JSONObject.quote(moreContext) + "," : "";
-        final String request = wrapJsonApiRequest("TripSearch", "{" //
-                + jsonContext //
-                + "\"depLocL\":[" + jsonLocation(from) + "]," //
-                + "\"arrLocL\":[" + jsonLocation(to) + "]," //
-                + (via != null ? "\"viaLocL\":[{\"loc\":" + jsonLocation(via) + "}]," : "") //
-                + "\"outDate\":\"" + outDate + "\"," //
-                + "\"outTime\":\"" + outTime + "\"," //
-                + "\"" + outFrwdKey + "\":" + outFrwd + "," //
-                + "\"jnyFltrL\":[{\"value\":\"" + jnyFltr + "\",\"mode\":\"BIT\",\"type\":\"PROD\"}]," //
-                + "\"gisFltrL\":[{\"mode\":\"FB\",\"profile\":{\"type\":\"F\",\"linDistRouting\":false,\"maxdist\":2000},\"type\":\"P\"}]," //
-                + "\"getPolyline\":false,\"getPasslist\":true,\"getIST\":false,\"getEco\":false,\"extChgTime\":-1}", //
-                false);
-
-        final HttpUrl url = checkNotNull(mgateEndpoint);
-        final CharSequence page = httpClient.get(url, request, "application/json");
-
-        try {
-            final JSONObject head = new JSONObject(page.toString());
-            final String headErr = head.optString("err", null);
-            if (headErr != null)
-                throw new RuntimeException(headErr);
-            final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, head.getString("ver"), null, 0, null);
-
-            final JSONArray svcResList = head.getJSONArray("svcResL");
-            checkState(svcResList.length() == 1);
-            final JSONObject svcRes = svcResList.optJSONObject(0);
-            checkState("TripSearch".equals(svcRes.getString("meth")));
-            final String err = svcRes.getString("err");
-            if (!"OK".equals(err)) {
-                final String errTxt = svcRes.getString("errTxt");
-                log.debug("Hafas error: {} {}", err, errTxt);
-                if ("H890".equals(err)) // No connections found.
-                    return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS);
-                if ("H891".equals(err)) // No route found (try entering an intermediate station).
-                    return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS);
-                if ("H895".equals(err)) // Departure/Arrival are too near.
-                    return new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE);
-                if ("H9220".equals(err)) // Nearby to the given address stations could not be found.
-                    return new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS);
-                if ("H9360".equals(err)) // Date outside of the timetable period.
-                    return new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE);
-                if ("H9380".equals(err)) // Departure/Arrival/Intermediate or equivalent stations def'd more
-                                         // than once.
-                    return new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE);
-                if ("FAIL".equals(err) && "HCI Service: request failed".equals(errTxt))
-                    return new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN);
-                throw new RuntimeException(err + " " + errTxt);
-            }
-            final JSONObject res = svcRes.getJSONObject("res");
-
-            final JSONObject common = res.getJSONObject("common");
-            /* final List<String[]> remarks = */ parseRemList(common.getJSONArray("remL"));
-            final List<Location> locations = parseLocList(common.getJSONArray("locL"));
-            final List<String> operators = parseOpList(common.getJSONArray("opL"));
-            final List<Line> lines = parseProdList(common.getJSONArray("prodL"), operators);
-
-            final JSONArray outConList = res.optJSONArray("outConL");
-            final List<Trip> trips = new ArrayList<Trip>(outConList.length());
-            for (int iOutCon = 0; iOutCon < outConList.length(); iOutCon++) {
-                final JSONObject outCon = outConList.getJSONObject(iOutCon);
-                final Location tripFrom = locations.get(outCon.getJSONObject("dep").getInt("locX"));
-                final Location tripTo = locations.get(outCon.getJSONObject("arr").getInt("locX"));
-
-                c.clear();
-                ParserUtils.parseIsoDate(c, outCon.getString("date"));
-                final Date baseDate = c.getTime();
-
-                final JSONArray secList = outCon.optJSONArray("secL");
-                final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(secList.length());
-                for (int iSec = 0; iSec < secList.length(); iSec++) {
-                    final JSONObject sec = secList.getJSONObject(iSec);
-                    final String secType = sec.getString("type");
-
-                    final JSONObject secDep = sec.getJSONObject("dep");
-                    final Stop departureStop = parseJsonStop(secDep, locations, c, baseDate);
-
-                    final JSONObject secArr = sec.getJSONObject("arr");
-                    final Stop arrivalStop = parseJsonStop(secArr, locations, c, baseDate);
-
-                    final Trip.Leg leg;
-                    if ("JNY".equals(secType)) {
-                        final JSONObject jny = sec.getJSONObject("jny");
-                        final Line line = lines.get(jny.getInt("prodX"));
-                        final String dirTxt = jny.optString("dirTxt", null);
-                        final Location destination = dirTxt != null ? new Location(LocationType.ANY, null, null, dirTxt)
-                                : null;
-
-                        final JSONArray stopList = jny.getJSONArray("stopL");
-                        checkState(stopList.length() >= 2);
-                        final List<Stop> intermediateStops = new ArrayList<Stop>(stopList.length());
-                        for (int iStop = 1; iStop < stopList.length() - 1; iStop++) {
-                            final JSONObject stop = stopList.getJSONObject(iStop);
-                            final Stop intermediateStop = parseJsonStop(stop, locations, c, baseDate);
-                            intermediateStops.add(intermediateStop);
-                        }
-
-                        leg = new Trip.Public(line, destination, departureStop, arrivalStop, intermediateStops, null,
-                                null);
-                    } else if ("WALK".equals(secType) || "TRSF".equals(secType)) {
-                        final JSONObject gis = sec.getJSONObject("gis");
-                        final int distance = gis.optInt("dist", 0);
-                        leg = new Trip.Individual(Trip.Individual.Type.WALK, departureStop.location,
-                                departureStop.getDepartureTime(), arrivalStop.location, arrivalStop.getArrivalTime(),
-                                null, distance);
-                    } else {
-                        throw new IllegalStateException("cannot handle type: " + secType);
-                    }
-
-                    legs.add(leg);
-                }
-
-                final JSONObject trfRes = outCon.optJSONObject("trfRes");
-                final List<Fare> fares = new LinkedList<Fare>();
-                if (trfRes != null) {
-                    final JSONArray fareSetList = trfRes.getJSONArray("fareSetL");
-                    for (int iFareSet = 0; iFareSet < fareSetList.length(); iFareSet++) {
-                        final JSONObject fareSet = fareSetList.getJSONObject(iFareSet);
-                        final String fareSetName = fareSet.optString("name", null);
-                        final String fareSetDescription = fareSet.optString("desc", null);
-                        if (fareSetName != null || fareSetDescription != null) {
-                            final JSONArray fareList = fareSet.getJSONArray("fareL");
-                            for (int iFare = 0; iFare < fareList.length(); iFare++) {
-                                final JSONObject jsonFare = fareList.getJSONObject(iFare);
-                                final String name = jsonFare.getString("name");
-                                final Currency currency = Currency.getInstance(jsonFare.getString("cur"));
-                                final float price = jsonFare.getInt("prc") / 100f;
-                                final Fare fare = parseJsonTripFare(fareSetName, fareSetDescription, name, currency,
-                                        price);
-                                if (fare != null)
-                                    fares.add(fare);
-                            }
-                        }
-                    }
-                }
-
-                final Trip trip = new Trip(null, tripFrom, tripTo, legs, fares, null, null);
-                trips.add(trip);
-            }
-
-            final JsonContext context = new JsonContext(from, via, to, time, dep, products, res.optString("outCtxScrF"),
-                    res.optString("outCtxScrB"));
-            return new QueryTripsResult(header, null, from, null, to, context, trips);
-        } catch (final JSONException x) {
-            throw new ParserException("cannot parse json: '" + page + "' on " + url, x);
-        }
-    }
-
-    protected Fare parseJsonTripFare(final @Nullable String fareSetName, final @Nullable String fareSetDescription,
-            final String name, final Currency currency, final float price) {
-        if (name.endsWith("- Jahreskarte") || name.endsWith("- Monatskarte"))
-            return null;
-        if (name.startsWith("Vollpreis - "))
-            return new Fare(fareSetName, Fare.Type.ADULT, currency, price, name.substring(12), null);
-        if (name.startsWith("Kind - "))
-            return new Fare(fareSetName, Fare.Type.CHILD, currency, price, name.substring(7), null);
-        return null;
-    }
-
-    private String wrapJsonApiRequest(final String meth, final String req, final boolean formatted) {
-        return "{" //
-                + "\"auth\":" + checkNotNull(jsonApiAuthorization) + "," //
-                + "\"client\":" + checkNotNull(jsonApiClient) + "," //
-                + "\"ver\":\"" + checkNotNull(jsonApiVersion) + "\",\"lang\":\"eng\"," //
-                + "\"svcReqL\":[{\"cfg\":{\"polyEnc\":\"GPA\"},\"meth\":\"" + meth + "\",\"req\":" + req + "}]," //
-                + "\"formatted\":" + formatted + "}";
-    }
-
-    private String jsonLocation(final Location location) {
-        if (location.type == LocationType.STATION && location.hasId())
-            return "{\"type\":\"S\",\"extId\":" + JSONObject.quote(location.id) + "}";
-        else if (location.type == LocationType.ADDRESS && location.hasId())
-            return "{\"type\":\"A\",\"lid\":" + JSONObject.quote(location.id) + "}";
-        else if (location.type == LocationType.POI && location.hasId())
-            return "{\"type\":\"P\",\"lid\":" + JSONObject.quote(location.id) + "}";
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    private CharSequence jsonDate(final Calendar time) {
-        final int year = time.get(Calendar.YEAR);
-        final int month = time.get(Calendar.MONTH) + 1;
-        final int day = time.get(Calendar.DAY_OF_MONTH);
-        return String.format(Locale.ENGLISH, "%04d%02d%02d", year, month, day);
-    }
-
-    private CharSequence jsonTime(final Calendar time) {
-        final int hour = time.get(Calendar.HOUR_OF_DAY);
-        final int minute = time.get(Calendar.MINUTE);
-        return String.format(Locale.ENGLISH, "%02d%02d00", hour, minute);
-    }
-
-    private static final Pattern P_JSON_TIME = Pattern.compile("(\\d{2})?(\\d{2})(\\d{2})(\\d{2})");
-
-    private final Date parseJsonTime(final Calendar calendar, final Date baseDate, final CharSequence str) {
-        if (str == null)
-            return null;
-
-        final Matcher m = P_JSON_TIME.matcher(str);
-        if (m.matches()) {
-            calendar.setTime(baseDate);
-
-            if (m.group(1) != null)
-                calendar.add(Calendar.DAY_OF_YEAR, Integer.parseInt(m.group(1)));
-            calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(m.group(2)));
-            calendar.set(Calendar.MINUTE, Integer.parseInt(m.group(3)));
-            calendar.set(Calendar.SECOND, Integer.parseInt(m.group(4)));
-
-            return calendar.getTime();
-        }
-
-        throw new RuntimeException("cannot parse: '" + str + "'");
-    }
-
-    private Stop parseJsonStop(final JSONObject json, final List<Location> locations, final Calendar c,
-            final Date baseDate) throws JSONException {
-        final Location location = locations.get(json.getInt("locX"));
-
-        final boolean arrivalCancelled = json.optBoolean("aCncl", false);
-        final Date plannedArrivalTime = parseJsonTime(c, baseDate, json.optString("aTimeS", null));
-        final Date predictedArrivalTime = parseJsonTime(c, baseDate, json.optString("aTimeR", null));
-        final Position plannedArrivalPosition = normalizePosition(json.optString("aPlatfS", null));
-        final Position predictedArrivalPosition = normalizePosition(json.optString("aPlatfR", null));
-
-        final boolean departureCancelled = json.optBoolean("dCncl", false);
-        final Date plannedDepartureTime = parseJsonTime(c, baseDate, json.optString("dTimeS", null));
-        final Date predictedDepartureTime = parseJsonTime(c, baseDate, json.optString("dTimeR", null));
-        final Position plannedDeparturePosition = normalizePosition(json.optString("dPlatfS", null));
-        final Position predictedDeparturePosition = normalizePosition(json.optString("dPlatfR", null));
-
-        return new Stop(location, plannedArrivalTime, predictedArrivalTime, plannedArrivalPosition,
-                predictedArrivalPosition, arrivalCancelled, plannedDepartureTime, predictedDepartureTime,
-                plannedDeparturePosition, predictedDeparturePosition, departureCancelled);
-    }
-
-    private List<String[]> parseRemList(final JSONArray remList) throws JSONException {
-        final List<String[]> remarks = new ArrayList<String[]>(remList.length());
-
-        for (int i = 0; i < remList.length(); i++) {
-            final JSONObject rem = remList.getJSONObject(i);
-            final String code = rem.getString("code");
-            final String txt = rem.getString("txtN");
-            remarks.add(new String[] { code, txt });
-        }
-
-        return remarks;
-    }
-
-    private List<Location> parseLocList(final JSONArray locList) throws JSONException {
-        final List<Location> locations = new ArrayList<Location>(locList.length());
-
-        for (int iLoc = 0; iLoc < locList.length(); iLoc++) {
-            final JSONObject loc = locList.getJSONObject(iLoc);
-            final String type = loc.getString("type");
-
-            final LocationType locationType;
-            final String id;
-            final String[] placeAndName;
-            final Set<Product> products;
-            if ("S".equals(type)) {
-                locationType = LocationType.STATION;
-                id = normalizeStationId(loc.getString("extId"));
-                placeAndName = splitStationName(loc.getString("name"));
-                final int pCls = loc.optInt("pCls", -1);
-                products = pCls != -1 ? intToProducts(pCls) : null;
-            } else if ("P".equals(type)) {
-                locationType = LocationType.POI;
-                id = loc.getString("lid");
-                placeAndName = splitPOI(loc.getString("name"));
-                products = null;
-            } else if ("A".equals(type)) {
-                locationType = LocationType.ADDRESS;
-                id = loc.getString("lid");
-                placeAndName = splitAddress(loc.getString("name"));
-                products = null;
-            } else {
-                throw new RuntimeException("Unknown type " + type + ": " + loc);
-            }
-
-            final JSONObject crd = loc.optJSONObject("crd");
-            if (crd != null)
-                locations.add(new Location(locationType, id, crd.getInt("y"), crd.getInt("x"), placeAndName[0],
-                        placeAndName[1], products));
-            else
-                locations.add(new Location(LocationType.STATION, id, null, placeAndName[0], placeAndName[1], products));
-        }
-
-        return locations;
-    }
-
-    private List<String> parseOpList(final JSONArray opList) throws JSONException {
-        final List<String> operators = new ArrayList<String>(opList.length());
-
-        for (int i = 0; i < opList.length(); i++) {
-            final JSONObject op = opList.getJSONObject(i);
-            final String operator = op.getString("name");
-            operators.add(operator);
-        }
-
-        return operators;
-    }
-
-    private List<Line> parseProdList(final JSONArray prodList, final List<String> operators) throws JSONException {
-        final List<Line> lines = new ArrayList<Line>(prodList.length());
-
-        for (int iProd = 0; iProd < prodList.length(); iProd++) {
-            final JSONObject prod = prodList.getJSONObject(iProd);
-            final int oprIndex = prod.optInt("oprX", -1);
-            final String operator = oprIndex != -1 ? operators.get(oprIndex) : null;
-            final int cls = prod.optInt("cls", -1);
-            final Product product = cls != -1 ? intToProduct(cls) : null;
-            final String name = prod.getString("name");
-            final String normalizedName;
-            if (product == Product.BUS && name.startsWith("Bus "))
-                normalizedName = name.substring(4);
-            else if (product == Product.TRAM && name.startsWith("Tram "))
-                normalizedName = name.substring(5);
-            else if (product == Product.SUBURBAN_TRAIN && name.startsWith("S "))
-                normalizedName = "S" + name.substring(2);
-            else
-                normalizedName = name;
-            final Line line = new Line(null, operator, product, normalizedName,
-                    lineStyle(operator, product, normalizedName));
-            lines.add(line);
-        }
-
-        return lines;
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return queryTripsBinary(from, via, to, date, dep, products, walkSpeed, accessibility, options);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        return queryMoreTripsBinary(context, later);
-    }
-
-    protected final QueryTripsResult queryTripsXml(Location from, @Nullable Location via, Location to, final Date date,
-            final boolean dep, final @Nullable Set<Product> products, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-
-        if (!from.isIdentified()) {
-            final List<Location> locations = suggestLocations(from.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, locations, null, null);
-            from = locations.get(0);
-        }
-
-        if (via != null && !via.isIdentified()) {
-            final List<Location> locations = suggestLocations(via.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, null, locations, null);
-            via = locations.get(0);
-        }
-
-        if (!to.isIdentified()) {
-            final List<Location> locations = suggestLocations(to.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, null, null, locations);
-            to = locations.get(0);
-        }
-
-        final Calendar c = new GregorianCalendar(timeZone);
-        c.setTime(date);
-
-        final CharSequence productsStr;
-        if (products != null)
-            productsStr = productsString(products);
-        else
-            productsStr = allProductsString();
-
-        final char bikeChar = (options != null && options.contains(Option.BIKE)) ? '1' : '0';
-
-        final StringBuilder conReq = new StringBuilder("<ConReq deliverPolyline=\"1\">");
-        conReq.append("<Start>").append(locationXml(from));
-        conReq.append("<Prod prod=\"").append(productsStr).append("\" bike=\"").append(bikeChar)
-                .append("\" couchette=\"0\" direct=\"0\" sleeper=\"0\"/>");
-        conReq.append("</Start>");
-        if (via != null) {
-            conReq.append("<Via>").append(locationXml(via));
-            if (via.type != LocationType.ADDRESS)
-                conReq.append("<Prod prod=\"").append(productsStr).append("\" bike=\"").append(bikeChar)
-                        .append("\" couchette=\"0\" direct=\"0\" sleeper=\"0\"/>");
-            conReq.append("</Via>");
-        }
-        conReq.append("<Dest>").append(locationXml(to)).append("</Dest>");
-        conReq.append("<ReqT a=\"").append(dep ? 0 : 1).append("\" date=\"")
-                .append(String.format(Locale.ENGLISH, "%04d.%02d.%02d", c.get(Calendar.YEAR), c.get(Calendar.MONTH) + 1,
-                        c.get(Calendar.DAY_OF_MONTH)))
-                .append("\" time=\"")
-                .append(String.format(Locale.ENGLISH, "%02d:%02d", c.get(Calendar.HOUR_OF_DAY), c.get(Calendar.MINUTE))
-                        + "\"/>");
-        conReq.append("<RFlags");
-        // number of trips backwards
-        conReq.append(" b=\"").append(0).append("\"");
-        // number of trips forwards
-        conReq.append(" f=\"").append(numTripsRequested).append("\"");
-        // percentual extension of change time
-        conReq.append(" chExtension=\"").append(walkSpeed == WalkSpeed.SLOW ? 50 : 0).append("\"");
-        // TODO nrChanges: max number of changes
-        conReq.append(" sMode=\"N\"/>");
-        conReq.append("</ConReq>");
-
-        return queryTripsXml(null, true, conReq, from, via, to);
-    }
-
-    protected final QueryTripsResult queryMoreTripsXml(final QueryTripsContext contextObj, final boolean later)
-            throws IOException {
-        final Context context = (Context) contextObj;
-
-        final StringBuilder conScrReq = new StringBuilder("<ConScrReq scrDir=\"").append(later ? 'F' : 'B')
-                .append("\" nrCons=\"").append(numTripsRequested).append("\">");
-        conScrReq.append("<ConResCtxt>").append(later ? context.laterContext : context.earlierContext)
-                .append("</ConResCtxt>");
-        conScrReq.append("</ConScrReq>");
-
-        return queryTripsXml(context, later, conScrReq, null, null, null);
-    }
-
-    private QueryTripsResult queryTripsXml(final Context previousContext, final boolean later,
-            final CharSequence conReq, final Location from, final @Nullable Location via, final Location to)
-            throws IOException {
-        final String request = wrapReqC(conReq, null);
-        final HttpUrl endpoint = extXmlEndpoint != null ? extXmlEndpoint
-                : queryEndpoint.newBuilder().addPathSegment(apiLanguage).build();
-        final AtomicReference<QueryTripsResult> result = new AtomicReference<QueryTripsResult>();
-        httpClient.getInputStream(new HttpClient.Callback() {
-            @Override
-            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
-                try {
-                    final XmlPullParserFactory factory = XmlPullParserFactory
-                            .newInstance(System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
-                    final XmlPullParser pp = factory.newPullParser();
-                    pp.setInput(body.charStream());
-
-                    XmlPullUtil.require(pp, "ResC");
-                    final String product = XmlPullUtil.attr(pp, "prod").split(" ")[0];
-                    final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, product, null, 0, null);
-                    XmlPullUtil.enter(pp, "ResC");
-
-                    if (XmlPullUtil.test(pp, "Err")) {
-                        final String code = XmlPullUtil.attr(pp, "code");
-                        if (code.equals("I3")) {
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
-                            return;
-                        }
-                        if (code.equals("F1")) {
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                            return;
-                        }
-                        throw new IllegalStateException("error " + code + " " + XmlPullUtil.attr(pp, "text"));
-                    }
-
-                    XmlPullUtil.enter(pp, "ConRes");
-
-                    if (XmlPullUtil.test(pp, "Err")) {
-                        final String code = XmlPullUtil.attr(pp, "code");
-                        log.debug("Hafas error: {}", code);
-                        if (code.equals("K9260")) {
-                            // Unknown departure station
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM));
-                            return;
-                        }
-                        if (code.equals("K9280")) {
-                            // Unknown intermediate station
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA));
-                            return;
-                        }
-                        if (code.equals("K9300")) {
-                            // Unknown arrival station
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO));
-                            return;
-                        }
-                        if (code.equals("K9360")) {
-                            // Date outside of the timetable period
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
-                            return;
-                        }
-                        if (code.equals("K9380")) {
-                            // Dep./Arr./Intermed. or equivalent station defined more than once
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
-                            return;
-                        }
-                        if (code.equals("K895")) {
-                            // Departure/Arrival are too near
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
-                            return;
-                        }
-                        if (code.equals("K9220")) {
-                            // Nearby to the given address stations could not be found
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS));
-                            return;
-                        }
-                        if (code.equals("K9240")) {
-                            // Internal error
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                            return;
-                        }
-                        if (code.equals("K890")) {
-                            // No connections found
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                            return;
-                        }
-                        if (code.equals("K891")) {
-                            // No route found (try entering an intermediate station)
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                            return;
-                        }
-                        if (code.equals("K899")) {
-                            // An error occurred
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                            return;
-                        }
-                        if (code.equals("K1:890")) {
-                            // Unsuccessful or incomplete search (direction: forward)
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                            return;
-                        }
-                        if (code.equals("K2:890")) {
-                            // Unsuccessful or incomplete search (direction: backward)
-                            result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                            return;
-                        }
-                        throw new IllegalStateException("error " + code + " " + XmlPullUtil.attr(pp, "text"));
-                    }
-
-                    // H9380 Dep./Arr./Intermed. or equivalent stations defined more than once
-                    // H9360 Error in data field
-                    // H9320 The input is incorrect or incomplete
-                    // H9300 Unknown arrival station
-                    // H9280 Unknown intermediate station
-                    // H9260 Unknown departure station
-                    // H9250 Part inquiry interrupted
-                    // H9240 Unsuccessful search
-                    // H9230 An internal error occurred
-                    // H9220 Nearby to the given address stations could not be found
-                    // H900 Unsuccessful or incomplete search (timetable change)
-                    // H892 Inquiry too complex (try entering less intermediate stations)
-                    // H891 No route found (try entering an intermediate station)
-                    // H890 Unsuccessful search.
-                    // H500 Because of too many trains the connection is not complete
-                    // H460 One or more stops are passed through multiple times.
-                    // H455 Prolonged stop
-                    // H410 Display may be incomplete due to change of timetable
-                    // H390 Departure/Arrival replaced by an equivalent station
-                    // H895 Departure/Arrival are too near
-                    // H899 Unsuccessful or incomplete search (timetable change
-
-                    final String c = XmlPullUtil.optValueTag(pp, "ConResCtxt", null);
-                    final Context context;
-                    if (previousContext == null)
-                        context = new Context(c, c, 0);
-                    else if (later)
-                        context = new Context(c, previousContext.earlierContext, previousContext.sequence + 1);
-                    else
-                        context = new Context(previousContext.laterContext, c, previousContext.sequence + 1);
-
-                    XmlPullUtil.enter(pp, "ConnectionList");
-
-                    final List<Trip> trips = new ArrayList<Trip>();
-
-                    while (XmlPullUtil.test(pp, "Connection")) {
-                        final String id = context.sequence + "/" + XmlPullUtil.attr(pp, "id");
-
-                        XmlPullUtil.enter(pp, "Connection");
-                        while (pp.getName().equals("RtStateList"))
-                            XmlPullUtil.next(pp);
-                        XmlPullUtil.enter(pp, "Overview");
-
-                        final Calendar currentDate = new GregorianCalendar(timeZone);
-                        currentDate.clear();
-                        parseDate(currentDate, XmlPullUtil.valueTag(pp, "Date"));
-                        XmlPullUtil.enter(pp, "Departure");
-                        XmlPullUtil.enter(pp, "BasicStop");
-                        while (pp.getName().equals("StAttrList"))
-                            XmlPullUtil.next(pp);
-                        final Location departureLocation = parseLocation(pp);
-                        XmlPullUtil.enter(pp, "Dep");
-                        XmlPullUtil.skipExit(pp, "Dep");
-                        final int[] capacity;
-                        if (XmlPullUtil.test(pp, "StopPrognosis")) {
-                            XmlPullUtil.enter(pp, "StopPrognosis");
-                            XmlPullUtil.optSkip(pp, "Arr");
-                            XmlPullUtil.optSkip(pp, "Dep");
-                            XmlPullUtil.enter(pp, "Status");
-                            XmlPullUtil.skipExit(pp, "Status");
-                            final int capacity1st = Integer.parseInt(XmlPullUtil.optValueTag(pp, "Capacity1st", "0"));
-                            final int capacity2nd = Integer.parseInt(XmlPullUtil.optValueTag(pp, "Capacity2nd", "0"));
-                            if (capacity1st > 0 || capacity2nd > 0)
-                                capacity = new int[] { capacity1st, capacity2nd };
-                            else
-                                capacity = null;
-                            XmlPullUtil.skipExit(pp, "StopPrognosis");
-                        } else {
-                            capacity = null;
-                        }
-                        XmlPullUtil.skipExit(pp, "BasicStop");
-                        XmlPullUtil.skipExit(pp, "Departure");
-
-                        XmlPullUtil.enter(pp, "Arrival");
-                        XmlPullUtil.enter(pp, "BasicStop");
-                        while (pp.getName().equals("StAttrList"))
-                            XmlPullUtil.next(pp);
-                        final Location arrivalLocation = parseLocation(pp);
-                        XmlPullUtil.skipExit(pp, "BasicStop");
-                        XmlPullUtil.skipExit(pp, "Arrival");
-
-                        final int numTransfers = Integer.parseInt(XmlPullUtil.valueTag(pp, "Transfers"));
-
-                        XmlPullUtil.skipExit(pp, "Overview");
-
-                        final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(4);
-
-                        XmlPullUtil.enter(pp, "ConSectionList");
-
-                        final Calendar time = new GregorianCalendar(timeZone);
-
-                        while (XmlPullUtil.test(pp, "ConSection")) {
-                            XmlPullUtil.enter(pp, "ConSection");
-
-                            // departure
-                            XmlPullUtil.enter(pp, "Departure");
-                            XmlPullUtil.enter(pp, "BasicStop");
-                            while (pp.getName().equals("StAttrList"))
-                                XmlPullUtil.next(pp);
-                            final Location sectionDepartureLocation = parseLocation(pp);
-
-                            XmlPullUtil.optSkip(pp, "Arr");
-                            XmlPullUtil.enter(pp, "Dep");
-                            time.setTimeInMillis(currentDate.getTimeInMillis());
-                            parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
-                            final Date departureTime = time.getTime();
-                            final Position departurePos = parsePlatform(pp);
-                            XmlPullUtil.skipExit(pp, "Dep");
-
-                            XmlPullUtil.skipExit(pp, "BasicStop");
-                            XmlPullUtil.skipExit(pp, "Departure");
-
-                            // journey
-                            final Line line;
-                            Location destination = null;
-
-                            List<Stop> intermediateStops = null;
-
-                            final String tag = pp.getName();
-                            if (tag.equals("Journey")) {
-                                XmlPullUtil.enter(pp, "Journey");
-                                while (pp.getName().equals("JHandle"))
-                                    XmlPullUtil.next(pp);
-                                XmlPullUtil.enter(pp, "JourneyAttributeList");
-                                boolean wheelchairAccess = false;
-                                String name = null;
-                                String category = null;
-                                String shortCategory = null;
-                                while (XmlPullUtil.test(pp, "JourneyAttribute")) {
-                                    XmlPullUtil.enter(pp, "JourneyAttribute");
-                                    XmlPullUtil.require(pp, "Attribute");
-                                    final String attrName = XmlPullUtil.attr(pp, "type");
-                                    final String code = XmlPullUtil.optAttr(pp, "code", null);
-                                    XmlPullUtil.enter(pp, "Attribute");
-                                    final Map<String, String> attributeVariants = parseAttributeVariants(pp);
-                                    XmlPullUtil.skipExit(pp, "Attribute");
-                                    XmlPullUtil.skipExit(pp, "JourneyAttribute");
-
-                                    if ("bf".equals(code)) {
-                                        wheelchairAccess = true;
-                                    } else if ("NAME".equals(attrName)) {
-                                        name = attributeVariants.get("NORMAL");
-                                    } else if ("CATEGORY".equals(attrName)) {
-                                        shortCategory = attributeVariants.get("SHORT");
-                                        category = attributeVariants.get("NORMAL");
-                                        // longCategory = attributeVariants.get("LONG");
-                                    } else if ("DIRECTION".equals(attrName)) {
-                                        final String[] destinationPlaceAndName = splitStationName(
-                                                attributeVariants.get("NORMAL"));
-                                        destination = new Location(LocationType.ANY, null, destinationPlaceAndName[0],
-                                                destinationPlaceAndName[1]);
-                                    }
-                                }
-                                XmlPullUtil.skipExit(pp, "JourneyAttributeList");
-
-                                if (XmlPullUtil.test(pp, "PassList")) {
-                                    intermediateStops = new LinkedList<Stop>();
-
-                                    XmlPullUtil.enter(pp, "PassList");
-                                    while (XmlPullUtil.test(pp, "BasicStop")) {
-                                        XmlPullUtil.enter(pp, "BasicStop");
-                                        while (XmlPullUtil.test(pp, "StAttrList"))
-                                            XmlPullUtil.next(pp);
-                                        final Location location = parseLocation(pp);
-                                        if (location.id != sectionDepartureLocation.id) {
-                                            Date stopArrivalTime = null;
-                                            Date stopDepartureTime = null;
-                                            Position stopArrivalPosition = null;
-                                            Position stopDeparturePosition = null;
-
-                                            if (XmlPullUtil.test(pp, "Arr")) {
-                                                XmlPullUtil.enter(pp, "Arr");
-                                                time.setTimeInMillis(currentDate.getTimeInMillis());
-                                                parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
-                                                stopArrivalTime = time.getTime();
-                                                stopArrivalPosition = parsePlatform(pp);
-                                                XmlPullUtil.skipExit(pp, "Arr");
-                                            }
-
-                                            if (XmlPullUtil.test(pp, "Dep")) {
-                                                XmlPullUtil.enter(pp, "Dep");
-                                                time.setTimeInMillis(currentDate.getTimeInMillis());
-                                                parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
-                                                stopDepartureTime = time.getTime();
-                                                stopDeparturePosition = parsePlatform(pp);
-                                                XmlPullUtil.skipExit(pp, "Dep");
-                                            }
-
-                                            intermediateStops.add(new Stop(location, stopArrivalTime,
-                                                    stopArrivalPosition, stopDepartureTime, stopDeparturePosition));
-                                        }
-                                        XmlPullUtil.skipExit(pp, "BasicStop");
-                                    }
-
-                                    XmlPullUtil.skipExit(pp, "PassList");
-                                }
-
-                                XmlPullUtil.skipExit(pp, "Journey");
-
-                                if (category == null)
-                                    category = shortCategory;
-
-                                line = parseLine(category, name, wheelchairAccess);
-                            } else if (tag.equals("Walk") || tag.equals("Transfer") || tag.equals("GisRoute")) {
-                                XmlPullUtil.enter(pp);
-                                XmlPullUtil.enter(pp, "Duration");
-                                XmlPullUtil.skipExit(pp, "Duration");
-                                XmlPullUtil.skipExit(pp);
-
-                                line = null;
-                            } else {
-                                throw new IllegalStateException("cannot handle: " + pp.getName());
-                            }
-
-                            // polyline
-                            final List<Point> path;
-                            if (XmlPullUtil.test(pp, "Polyline")) {
-                                path = new LinkedList<Point>();
-                                XmlPullUtil.enter(pp, "Polyline");
-                                while (XmlPullUtil.test(pp, "Point")) {
-                                    final int x = XmlPullUtil.intAttr(pp, "x");
-                                    final int y = XmlPullUtil.intAttr(pp, "y");
-                                    path.add(new Point(y, x));
-                                    XmlPullUtil.next(pp);
-                                }
-                                XmlPullUtil.skipExit(pp, "Polyline");
-                            } else {
-                                path = null;
-                            }
-
-                            // arrival
-                            XmlPullUtil.enter(pp, "Arrival");
-                            XmlPullUtil.enter(pp, "BasicStop");
-                            while (pp.getName().equals("StAttrList"))
-                                XmlPullUtil.next(pp);
-                            final Location sectionArrivalLocation = parseLocation(pp);
-                            XmlPullUtil.enter(pp, "Arr");
-                            time.setTimeInMillis(currentDate.getTimeInMillis());
-                            parseTime(time, XmlPullUtil.valueTag(pp, "Time"));
-                            final Date arrivalTime = time.getTime();
-                            final Position arrivalPos = parsePlatform(pp);
-                            XmlPullUtil.skipExit(pp, "Arr");
-
-                            XmlPullUtil.skipExit(pp, "BasicStop");
-                            XmlPullUtil.skipExit(pp, "Arrival");
-
-                            // remove last intermediate
-                            if (intermediateStops != null)
-                                if (!intermediateStops.isEmpty())
-                                    if (!intermediateStops.get(intermediateStops.size() - 1).location
-                                            .equals(sectionArrivalLocation))
-                                        intermediateStops.remove(intermediateStops.size() - 1);
-
-                            XmlPullUtil.skipExit(pp, "ConSection");
-
-                            if (line != null) {
-                                final Stop departure = new Stop(sectionDepartureLocation, true, departureTime, null,
-                                        departurePos, null);
-                                final Stop arrival = new Stop(sectionArrivalLocation, false, arrivalTime, null,
-                                        arrivalPos, null);
-
-                                legs.add(new Trip.Public(line, destination, departure, arrival, intermediateStops, path,
-                                        null));
-                            } else {
-                                if (legs.size() > 0 && legs.get(legs.size() - 1) instanceof Trip.Individual) {
-                                    final Trip.Individual lastIndividualLeg = (Trip.Individual) legs
-                                            .remove(legs.size() - 1);
-                                    legs.add(new Trip.Individual(Trip.Individual.Type.WALK, lastIndividualLeg.departure,
-                                            lastIndividualLeg.departureTime, sectionArrivalLocation, arrivalTime, null,
-                                            0));
-                                } else {
-                                    legs.add(new Trip.Individual(Trip.Individual.Type.WALK, sectionDepartureLocation,
-                                            departureTime, sectionArrivalLocation, arrivalTime, null, 0));
-                                }
-                            }
-                        }
-
-                        XmlPullUtil.skipExit(pp, "ConSectionList");
-
-                        XmlPullUtil.skipExit(pp, "Connection");
-
-                        trips.add(new Trip(id, departureLocation, arrivalLocation, legs, null, capacity, numTransfers));
-                    }
-
-                    XmlPullUtil.skipExit(pp, "ConnectionList");
-
-                    result.set(new QueryTripsResult(header, null, from, via, to, context, trips));
-                } catch (final XmlPullParserException x) {
-                    throw new ParserException("cannot parse xml: " + bodyPeek, x);
-                }
-            }
-        }, endpoint, request, "application/xml", null);
-
-        return result.get();
-    }
-
-    private final Location parseLocation(final XmlPullParser pp) throws XmlPullParserException, IOException {
-        final Location location;
-        if (pp.getName().equals("Station"))
-            location = parseStation(pp);
-        else if (pp.getName().equals("Poi"))
-            location = parsePoi(pp);
-        else if (pp.getName().equals("Address"))
-            location = parseAddress(pp);
-        else
-            throw new IllegalStateException("cannot parse: " + pp.getName());
-        XmlPullUtil.next(pp);
-        return location;
-    }
-
-    private final Map<String, String> parseAttributeVariants(final XmlPullParser pp)
-            throws XmlPullParserException, IOException {
-        final Map<String, String> attributeVariants = new HashMap<String, String>();
-
-        while (XmlPullUtil.test(pp, "AttributeVariant")) {
-            final String type = XmlPullUtil.attr(pp, "type");
-            XmlPullUtil.enter(pp, "AttributeVariant");
-            final String value = XmlPullUtil.optValueTag(pp, "Text", null);
-            XmlPullUtil.skipExit(pp, "AttributeVariant");
-
-            attributeVariants.put(type, value);
-        }
-
-        return attributeVariants;
-    }
-
-    private static final Pattern P_DATE = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");
-
-    private static final void parseDate(final Calendar calendar, final CharSequence str) {
-        final Matcher m = P_DATE.matcher(str);
-        if (!m.matches())
-            throw new RuntimeException("cannot parse: '" + str + "'");
-
-        calendar.set(Calendar.YEAR, Integer.parseInt(m.group(1)));
-        calendar.set(Calendar.MONTH, Integer.parseInt(m.group(2)) - 1);
-        calendar.set(Calendar.DAY_OF_MONTH, Integer.parseInt(m.group(3)));
-    }
-
-    private static final Pattern P_TIME = Pattern.compile("(\\d+)d(\\d+):(\\d{2}):(\\d{2})");
-
-    private static void parseTime(final Calendar calendar, final CharSequence str) {
-        final Matcher m = P_TIME.matcher(str);
-        if (!m.matches())
-            throw new IllegalArgumentException("cannot parse: '" + str + "'");
-
-        calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(m.group(2)));
-        calendar.set(Calendar.MINUTE, Integer.parseInt(m.group(3)));
-        calendar.set(Calendar.SECOND, Integer.parseInt(m.group(4)));
-        calendar.set(Calendar.MILLISECOND, 0);
-        calendar.add(Calendar.DAY_OF_MONTH, Integer.parseInt(m.group(1)));
-    }
-
-    private static final String locationXml(final Location location) {
-        if (location.type == LocationType.STATION && location.hasId())
-            return "<Station externalId=\"" + normalizeStationId(location.id) + "\" />";
-        else if (location.type == LocationType.POI && location.hasLocation())
-            return "<Poi type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" />";
-        else if (location.type == LocationType.ADDRESS && location.hasLocation())
-            return "<Address type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" name=\""
-                    + (location.place != null ? location.place + ", " : "") + location.name + "\" />";
-        else if (location.type == LocationType.COORD && location.hasLocation())
-            return "<Coord type=\"WGS84\" x=\"" + location.lon + "\" y=\"" + location.lat + "\" />";
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    protected final String locationId(final Location location) {
-        final StringBuilder id = new StringBuilder();
-
-        id.append("A=").append(locationType(location));
-
-        if (location.type == LocationType.STATION && location.hasId()) {
-            id.append("@L=").append(normalizeStationId(location.id));
-        } else if (location.hasLocation()) {
-            id.append("@X=").append(location.lon);
-            id.append("@Y=").append(location.lat);
-            id.append("@O=").append(location.name != null ? location.name
-                    : String.format(Locale.ENGLISH, "%.6f, %.6f", location.lat / 1E6, location.lon / 1E6));
-        } else if (location.name != null) {
-            id.append("@G=").append(location.name);
-            if (location.type != LocationType.ANY)
-                id.append('!');
-        }
-
-        return id.toString();
-    }
-
-    protected static final int locationType(final Location location) {
-        final LocationType type = location.type;
-        if (type == LocationType.STATION)
-            return 1;
-        if (type == LocationType.POI)
-            return 4;
-        if (type == LocationType.COORD || (type == LocationType.ADDRESS && location.hasLocation()))
-            return 16;
-        if (type == LocationType.ADDRESS && location.name != null)
-            return 2;
-        if (type == LocationType.ANY)
-            return 255;
-        throw new IllegalArgumentException(location.type.toString());
-    }
-
-    protected void appendQueryTripsBinaryParameters(final HttpUrl.Builder url, final Location from,
-            final @Nullable Location via, final Location to, final Date date, final boolean dep,
-            final @Nullable Set<Product> products, final @Nullable Accessibility accessibility,
-            final @Nullable Set<Option> options) {
-        url.addQueryParameter("start", "Suchen");
-        url.addEncodedQueryParameter("REQ0JourneyStopsS0ID",
-                ParserUtils.urlEncode(locationId(from), requestUrlEncoding));
-        url.addEncodedQueryParameter("REQ0JourneyStopsZ0ID", ParserUtils.urlEncode(locationId(to), requestUrlEncoding));
-
-        if (via != null) {
-            // workaround, for there does not seem to be a REQ0JourneyStops1.0ID parameter
-            url.addQueryParameter("REQ0JourneyStops1.0A", Integer.toString(locationType(via)));
-
-            if (via.type == LocationType.STATION && via.hasId()) {
-                url.addQueryParameter("REQ0JourneyStops1.0L", via.id);
-            } else if (via.hasLocation()) {
-                url.addQueryParameter("REQ0JourneyStops1.0X", Integer.toString(via.lon));
-                url.addQueryParameter("REQ0JourneyStops1.0Y", Integer.toString(via.lat));
-                if (via.name == null)
-                    url.addQueryParameter("REQ0JourneyStops1.0O",
-                            String.format(Locale.ENGLISH, "%.6f, %.6f", via.lat / 1E6, via.lon / 1E6));
-            } else if (via.name != null) {
-                url.addEncodedQueryParameter("REQ0JourneyStops1.0G", ParserUtils
-                        .urlEncode(via.name + (via.type != LocationType.ANY ? "!" : ""), requestUrlEncoding));
-            }
-        }
-
-        url.addQueryParameter("REQ0HafasSearchForw", dep ? "1" : "0");
-
-        appendDateTimeParameters(url, date, "REQ0JourneyDate", "REQ0JourneyTime");
-
-        final CharSequence productsStr;
-        if (products != null)
-            productsStr = productsString(products);
-        else
-            productsStr = allProductsString();
-        url.addQueryParameter("REQ0JourneyProduct_prod_list_1", productsStr.toString());
-
-        if (accessibility != null && accessibility != Accessibility.NEUTRAL) {
-            if (accessibility == Accessibility.LIMITED)
-                url.addQueryParameter("REQ0AddParamBaimprofile", "1");
-            else if (accessibility == Accessibility.BARRIER_FREE)
-                url.addQueryParameter("REQ0AddParamBaimprofile", "0");
-        }
-
-        if (options != null && options.contains(Option.BIKE))
-            url.addQueryParameter("REQ0JourneyProduct_opt3", "1");
-
-        appendCommonQueryTripsBinaryParameters(url);
-    }
-
-    protected void appendCommonQueryTripsBinaryParameters(final HttpUrl.Builder url) {
-        url.addQueryParameter("h2g-direct", "11");
-        if (clientType != null)
-            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
-    }
-
-    private final static int QUERY_TRIPS_BINARY_BUFFER_SIZE = 384 * 1024;
-
-    protected final QueryTripsResult queryTripsBinary(Location from, @Nullable Location via, Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable WalkSpeed walkSpeed, final @Nullable Accessibility accessibility,
-            final @Nullable Set<Option> options) throws IOException {
-        final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT);
-
-        if (!from.isIdentified()) {
-            final List<Location> locations = suggestLocations(from.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, locations, null, null);
-            from = locations.get(0);
-        }
-
-        if (via != null && !via.isIdentified()) {
-            final List<Location> locations = suggestLocations(via.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, null, locations, null);
-            via = locations.get(0);
-        }
-
-        if (!to.isIdentified()) {
-            final List<Location> locations = suggestLocations(to.name).getLocations();
-            if (locations.isEmpty())
-                return new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS); // TODO
-            if (locations.size() > 1)
-                return new QueryTripsResult(header, null, null, locations);
-            to = locations.get(0);
-        }
-
-        final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage);
-        appendQueryTripsBinaryParameters(url, from, via, to, date, dep, products, accessibility, options);
-        return queryTripsBinary(url.build(), from, via, to, QUERY_TRIPS_BINARY_BUFFER_SIZE);
-    }
-
-    protected void appendQueryMoreTripsBinaryParameters(final HttpUrl.Builder url,
-            final QueryTripsBinaryContext context, final boolean later) {
-        url.addQueryParameter("seqnr", Integer.toString(context.seqNr));
-        url.addQueryParameter("ident", context.ident);
-        if (context.ld != null)
-            url.addQueryParameter("ld", context.ld);
-        url.addQueryParameter("REQ0HafasScrollDir", later ? "1" : "2");
-        appendCommonQueryTripsBinaryParameters(url);
-    }
-
-    protected QueryTripsResult queryMoreTripsBinary(final QueryTripsContext contextObj, final boolean later)
-            throws IOException {
-        final QueryTripsBinaryContext context = (QueryTripsBinaryContext) contextObj;
-
-        final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage);
-        appendQueryMoreTripsBinaryParameters(url, context, later);
-        return queryTripsBinary(url.build(), null, null, null, QUERY_TRIPS_BINARY_BUFFER_SIZE + context.usedBufferSize);
-    }
-
-    private class CustomBufferedInputStream extends BufferedInputStream {
-        public CustomBufferedInputStream(final InputStream in) {
-            super(in);
-        }
-
-        public int getCount() {
-            return count;
-        }
-    }
-
-    private QueryTripsResult queryTripsBinary(final HttpUrl url, final Location from, final @Nullable Location via,
-            final Location to, final int expectedBufferSize) throws IOException {
-        /*
-         * Many thanks to Malte Starostik and Robert, who helped a lot with analyzing this API!
-         */
-
-        final AtomicReference<QueryTripsResult> result = new AtomicReference<QueryTripsResult>();
-
-        httpClient.getInputStream(new HttpClient.Callback() {
-            @Override
-            public void onSuccessful(final CharSequence bodyPeek, final ResponseBody body) throws IOException {
-                final CustomBufferedInputStream bis = new CustomBufferedInputStream(
-                        new GZIPInputStream(body.byteStream()));
-
-                // initialize input stream
-                final LittleEndianDataInputStream is = new LittleEndianDataInputStream(bis);
-                is.mark(expectedBufferSize);
-
-                // quick check of status
-                final int version = is.readShortReverse();
-                if (version != 6 && version != 5)
-                    throw new IllegalStateException("unknown version: " + version + ", first chars: " + bodyPeek);
-                final ResultHeader header = new ResultHeader(network, SERVER_PRODUCT, Integer.toString(version), null,
-                        0, null);
-
-                // quick seek for pointers
-                is.reset();
-                is.skipBytes(0x20);
-                final int serviceDaysTablePtr = is.readIntReverse();
-                final int stringTablePtr = is.readIntReverse();
-
-                is.reset();
-                is.skipBytes(0x36);
-                final int stationTablePtr = is.readIntReverse();
-                final int commentTablePtr = is.readIntReverse();
-
-                is.reset();
-                is.skipBytes(0x46);
-                final int extensionHeaderPtr = is.readIntReverse();
-
-                // read strings
-                final StringTable strings = new StringTable(is, stringTablePtr, serviceDaysTablePtr - stringTablePtr);
-
-                is.reset();
-                is.skipBytes(extensionHeaderPtr);
-
-                // read extension header
-                final int extensionHeaderLength = is.readIntReverse();
-                if (extensionHeaderLength < 0x2c)
-                    throw new IllegalStateException("too short: " + extensionHeaderLength);
-
-                is.skipBytes(12);
-                final int errorCode = is.readShortReverse();
-
-                if (errorCode == 0) {
-                    // string encoding
-                    is.skipBytes(14);
-                    final Charset stringEncoding = Charset.forName(strings.read(is));
-                    strings.setEncoding(stringEncoding);
-
-                    // read number of trips
-                    is.reset();
-                    is.skipBytes(30);
-
-                    final int numTrips = is.readShortReverse();
-                    if (numTrips == 0) {
-                        result.set(new QueryTripsResult(header, url.toString(), from, via, to, null,
-                                new LinkedList<Trip>()));
-                        return;
-                    }
-
-                    // read rest of header
-                    is.reset();
-                    is.skipBytes(0x02);
-
-                    final Location resDeparture = location(is, strings);
-                    final Location resArrival = location(is, strings);
-
-                    is.skipBytes(10);
-
-                    final long resDate = date(is);
-                    /* final long resDate30 = */date(is);
-
-                    is.reset();
-                    is.skipBytes(extensionHeaderPtr + 0x8);
-
-                    final int seqNr = is.readShortReverse();
-                    if (seqNr == 0)
-                        throw new SessionExpiredException();
-                    else if (seqNr < 0)
-                        throw new IllegalStateException("illegal sequence number: " + seqNr);
-
-                    final String requestId = strings.read(is);
-
-                    final int tripDetailsPtr = is.readIntReverse();
-                    if (tripDetailsPtr == 0)
-                        throw new IllegalStateException("no connection details");
-
-                    is.skipBytes(4);
-
-                    final int disruptionsPtr = is.readIntReverse();
-
-                    is.skipBytes(10);
-
-                    final String ld = strings.read(is);
-                    final int attrsOffset = is.readIntReverse();
-
-                    final int tripAttrsPtr;
-                    if (extensionHeaderLength >= 0x30) {
-                        if (extensionHeaderLength < 0x32)
-                            throw new IllegalArgumentException("too short: " + extensionHeaderLength);
-                        is.reset();
-                        is.skipBytes(extensionHeaderPtr + 0x2c);
-                        tripAttrsPtr = is.readIntReverse();
-                    } else {
-                        tripAttrsPtr = 0;
-                    }
-
-                    // determine stops offset
-                    is.reset();
-                    is.skipBytes(tripDetailsPtr);
-                    final int tripDetailsVersion = is.readShortReverse();
-                    if (tripDetailsVersion != 1)
-                        throw new IllegalStateException("unknown trip details version: " + tripDetailsVersion);
-                    is.skipBytes(0x02);
-
-                    final int tripDetailsIndexOffset = is.readShortReverse();
-                    final int tripDetailsLegOffset = is.readShortReverse();
-                    final int tripDetailsLegSize = is.readShortReverse();
-                    final int stopsSize = is.readShortReverse();
-                    final int stopsOffset = is.readShortReverse();
-
-                    // read stations
-                    final StationTable stations = new StationTable(is, stationTablePtr,
-                            commentTablePtr - stationTablePtr, strings);
-
-                    // read comments
-                    final CommentTable comments = new CommentTable(is, commentTablePtr,
-                            tripDetailsPtr - commentTablePtr, strings);
-
-                    final List<Trip> trips = new ArrayList<Trip>(numTrips);
-
-                    // read trips
-                    for (int iTrip = 0; iTrip < numTrips; iTrip++) {
-                        is.reset();
-                        is.skipBytes(0x4a + iTrip * 12);
-
-                        final int serviceDaysTableOffset = is.readShortReverse();
-
-                        final int legsOffset = is.readIntReverse();
-
-                        final int numLegs = is.readShortReverse();
-
-                        final int numChanges = is.readShortReverse();
-
-                        /* final long duration = time(is, 0, 0); */is.readShortReverse();
-
-                        is.reset();
-                        is.skipBytes(serviceDaysTablePtr + serviceDaysTableOffset);
-
-                        /* final String serviceDaysText = */strings.read(is);
-
-                        final int serviceBitBase = is.readShortReverse();
-                        final int serviceBitLength = is.readShortReverse();
-
-                        int tripDayOffset = serviceBitBase * 8;
-                        for (int i = 0; i < serviceBitLength; i++) {
-                            int serviceBits = is.read();
-                            if (serviceBits == 0) {
-                                tripDayOffset += 8;
-                                continue;
-                            }
-                            while ((serviceBits & 0x80) == 0) {
-                                serviceBits = serviceBits << 1;
-                                tripDayOffset++;
-                            }
-                            break;
-                        }
-
-                        is.reset();
-                        is.skipBytes(tripDetailsPtr + tripDetailsIndexOffset + iTrip * 2);
-                        final int tripDetailsOffset = is.readShortReverse();
-
-                        is.reset();
-                        is.skipBytes(tripDetailsPtr + tripDetailsOffset);
-                        final int realtimeStatus = is.readShortReverse();
-
-                        /* final short delay = */is.readShortReverse();
-
-                        /* final int legIndex = */is.readShortReverse();
-
-                        is.skipBytes(2); // 0xffff
-
-                        /* final int legStatus = */is.readShortReverse();
-
-                        is.skipBytes(2); // 0x0000
-
-                        String connectionId = null;
-                        if (tripAttrsPtr != 0) {
-                            is.reset();
-                            is.skipBytes(tripAttrsPtr + iTrip * 2);
-                            final int tripAttrsIndex = is.readShortReverse();
-
-                            is.reset();
-                            is.skipBytes(attrsOffset + tripAttrsIndex * 4);
-                            while (true) {
-                                final String key = strings.read(is);
-                                if (key == null)
-                                    break;
-                                else if (key.equals("ConnectionId"))
-                                    connectionId = strings.read(is);
-                                else
-                                    is.skipBytes(2);
-                            }
-                        }
-
-                        final List<Trip.Leg> legs = new ArrayList<Trip.Leg>(numLegs);
-
-                        for (int iLegs = 0; iLegs < numLegs; iLegs++) {
-                            is.reset();
-                            is.skipBytes(0x4a + legsOffset + iLegs * 20);
-
-                            final long plannedDepartureTime = time(is, resDate, tripDayOffset);
-                            final Location departureLocation = stations.read(is);
-
-                            final long plannedArrivalTime = time(is, resDate, tripDayOffset);
-                            final Location arrivalLocation = stations.read(is);
-
-                            final int type = is.readShortReverse();
-
-                            final String lineName = strings.read(is);
-
-                            final Position plannedDeparturePosition = normalizePosition(strings.read(is));
-                            final Position plannedArrivalPosition = normalizePosition(strings.read(is));
-
-                            final int legAttrIndex = is.readShortReverse();
-
-                            final List<Line.Attr> lineAttrs = new ArrayList<Line.Attr>();
-                            String lineComment = null;
-                            boolean lineOnDemand = false;
-                            for (final String comment : comments.read(is)) {
-                                if (comment.startsWith("bf ")) {
-                                    lineAttrs.add(Line.Attr.WHEEL_CHAIR_ACCESS);
-                                } else if (comment.startsWith("FA ") || comment.startsWith("FB ")
-                                        || comment.startsWith("FR ")) {
-                                    lineAttrs.add(Line.Attr.BICYCLE_CARRIAGE);
-                                } else if (comment.startsWith("$R ") || comment.startsWith("ga ")
-                                        || comment.startsWith("ja ") || comment.startsWith("Vs ")
-                                        || comment.startsWith("mu ") || comment.startsWith("mx ")) {
-                                    lineOnDemand = true;
-                                    lineComment = comment.substring(5);
-                                }
-                            }
-
-                            is.reset();
-                            is.skipBytes(attrsOffset + legAttrIndex * 4);
-                            String directionStr = null;
-                            int lineClass = 0;
-                            String lineCategory = null;
-                            String routingType = null;
-                            String lineNetwork = null;
-                            while (true) {
-                                final String key = strings.read(is);
-                                if (key == null)
-                                    break;
-                                else if (key.equals("Direction"))
-                                    directionStr = strings.read(is);
-                                else if (key.equals("Class"))
-                                    lineClass = Integer.parseInt(strings.read(is));
-                                else if (key.equals("Category"))
-                                    lineCategory = strings.read(is);
-                                // else if (key.equals("Operator"))
-                                // lineOperator = strings.read(is);
-                                else if (key.equals("GisRoutingType"))
-                                    routingType = strings.read(is);
-                                else if (key.equals("AdminCode"))
-                                    lineNetwork = normalizeLineAdministration(strings.read(is));
-                                else
-                                    is.skipBytes(2);
-                            }
-
-                            if (lineCategory == null && lineName != null)
-                                lineCategory = categoryFromName(lineName);
-
-                            is.reset();
-                            is.skipBytes(tripDetailsPtr + tripDetailsOffset + tripDetailsLegOffset
-                                    + iLegs * tripDetailsLegSize);
-
-                            if (tripDetailsLegSize != 16)
-                                throw new IllegalStateException(
-                                        "unhandled trip details leg size: " + tripDetailsLegSize);
-
-                            final long predictedDepartureTime = time(is, resDate, tripDayOffset);
-                            final long predictedArrivalTime = time(is, resDate, tripDayOffset);
-                            final Position predictedDeparturePosition = normalizePosition(strings.read(is));
-                            final Position predictedArrivalPosition = normalizePosition(strings.read(is));
-
-                            final int bits = is.readShortReverse();
-                            final boolean arrivalCancelled = (bits & 0x10) != 0;
-                            final boolean departureCancelled = (bits & 0x20) != 0;
-
-                            is.readShort();
-
-                            final int firstStopIndex = is.readShortReverse();
-
-                            final int numStops = is.readShortReverse();
-
-                            is.reset();
-                            is.skipBytes(disruptionsPtr);
-
-                            String disruptionText = null;
-
-                            if (is.readShortReverse() == 1) {
-                                is.reset();
-                                is.skipBytes(disruptionsPtr + 2 + iTrip * 2);
-
-                                int disruptionsOffset = is.readShortReverse();
-                                while (disruptionsOffset != 0) {
-                                    is.reset();
-                                    is.skipBytes(disruptionsPtr + disruptionsOffset);
-
-                                    strings.read(is); // "0"
-
-                                    final int disruptionLeg = is.readShortReverse();
-
-                                    is.skipBytes(2); // bitmaske
-
-                                    strings.read(is); // start of line
-                                    strings.read(is); // end of line
-
-                                    strings.read(is);
-                                    // id
-                                    /* final String disruptionTitle = */strings.read(is);
-                                    final String disruptionShortText = ParserUtils.formatHtml(strings.read(is));
-
-                                    disruptionsOffset = is.readShortReverse(); // next
-
-                                    if (iLegs == disruptionLeg) {
-                                        final int disruptionAttrsIndex = is.readShortReverse();
-
-                                        is.reset();
-                                        is.skipBytes(attrsOffset + disruptionAttrsIndex * 4);
-
-                                        while (true) {
-                                            final String key = strings.read(is);
-                                            if (key == null)
-                                                break;
-                                            else if (key.equals("Text"))
-                                                disruptionText = ParserUtils.resolveEntities(strings.read(is));
-                                            else
-                                                is.skipBytes(2);
-                                        }
-
-                                        if (disruptionShortText != null)
-                                            disruptionText = disruptionShortText;
-                                    }
-                                }
-                            }
-
-                            List<Stop> intermediateStops = null;
-
-                            if (numStops > 0) {
-                                is.reset();
-                                is.skipBytes(tripDetailsPtr + stopsOffset + firstStopIndex * stopsSize);
-
-                                if (stopsSize != 26)
-                                    throw new IllegalStateException("unhandled stops size: " + stopsSize);
-
-                                intermediateStops = new ArrayList<Stop>(numStops);
-
-                                for (int iStop = 0; iStop < numStops; iStop++) {
-                                    final long plannedStopDepartureTime = time(is, resDate, tripDayOffset);
-                                    final Date plannedStopDepartureDate = plannedStopDepartureTime != 0
-                                            ? new Date(plannedStopDepartureTime) : null;
-                                    final long plannedStopArrivalTime = time(is, resDate, tripDayOffset);
-                                    final Date plannedStopArrivalDate = plannedStopArrivalTime != 0
-                                            ? new Date(plannedStopArrivalTime) : null;
-                                    final Position plannedStopDeparturePosition = normalizePosition(strings.read(is));
-                                    final Position plannedStopArrivalPosition = normalizePosition(strings.read(is));
-
-                                    is.readInt();
-
-                                    final long predictedStopDepartureTime = time(is, resDate, tripDayOffset);
-                                    final Date predictedStopDepartureDate = predictedStopDepartureTime != 0
-                                            ? new Date(predictedStopDepartureTime) : null;
-                                    final long predictedStopArrivalTime = time(is, resDate, tripDayOffset);
-                                    final Date predictedStopArrivalDate = predictedStopArrivalTime != 0
-                                            ? new Date(predictedStopArrivalTime) : null;
-                                    final Position predictedStopDeparturePosition = normalizePosition(strings.read(is));
-                                    final Position predictedStopArrivalPosition = normalizePosition(strings.read(is));
-
-                                    final int stopBits = is.readShortReverse();
-                                    final boolean stopArrivalCancelled = (stopBits & 0x10) != 0;
-                                    final boolean stopDepartureCancelled = (stopBits & 0x20) != 0;
-
-                                    is.readShort();
-
-                                    final Location stopLocation = stations.read(is);
-
-                                    final boolean validPredictedDate = !dominantPlanStopTime
-                                            || (plannedStopArrivalDate != null && plannedStopDepartureDate != null);
-
-                                    final Stop stop = new Stop(stopLocation, plannedStopArrivalDate,
-                                            validPredictedDate ? predictedStopArrivalDate : null,
-                                            plannedStopArrivalPosition, predictedStopArrivalPosition,
-                                            stopArrivalCancelled, plannedStopDepartureDate,
-                                            validPredictedDate ? predictedStopDepartureDate : null,
-                                            plannedStopDeparturePosition, predictedStopDeparturePosition,
-                                            stopDepartureCancelled);
-
-                                    intermediateStops.add(stop);
-                                }
-                            }
-
-                            final Trip.Leg leg;
-                            if (type == 1 /* Fussweg */ || type == 3 /* Uebergang */ || type == 4 /* Uebergang */) {
-                                final Trip.Individual.Type individualType;
-                                if (routingType == null)
-                                    individualType = type == 1 ? Trip.Individual.Type.WALK
-                                            : Trip.Individual.Type.TRANSFER;
-                                else if ("FOOT".equals(routingType))
-                                    individualType = Trip.Individual.Type.WALK;
-                                else if ("BIKE".equals(routingType))
-                                    individualType = Trip.Individual.Type.BIKE;
-                                else if ("CAR".equals(routingType) || "P+R".equals(routingType))
-                                    individualType = Trip.Individual.Type.CAR;
-                                else
-                                    throw new IllegalStateException("unknown routingType: " + routingType);
-
-                                final Date departureTime = new Date(
-                                        predictedDepartureTime != 0 ? predictedDepartureTime : plannedDepartureTime);
-                                final Date arrivalTime = new Date(
-                                        predictedArrivalTime != 0 ? predictedArrivalTime : plannedArrivalTime);
-
-                                final Trip.Leg lastLeg = legs.size() > 0 ? legs.get(legs.size() - 1) : null;
-                                if (lastLeg != null && lastLeg instanceof Trip.Individual
-                                        && ((Trip.Individual) lastLeg).type == individualType) {
-                                    final Trip.Individual lastIndividualLeg = (Trip.Individual) legs
-                                            .remove(legs.size() - 1);
-                                    leg = new Trip.Individual(individualType, lastIndividualLeg.departure,
-                                            lastIndividualLeg.departureTime, arrivalLocation, arrivalTime, null, 0);
-                                } else {
-                                    leg = new Trip.Individual(individualType, departureLocation, departureTime,
-                                            arrivalLocation, arrivalTime, null, 0);
-                                }
-                            } else if (type == 2) {
-                                final Product lineProduct;
-                                if (lineOnDemand)
-                                    lineProduct = Product.ON_DEMAND;
-                                else if (lineClass != 0)
-                                    lineProduct = intToProduct(lineClass);
-                                else
-                                    lineProduct = normalizeType(lineCategory);
-
-                                final Line line = newLine(lineNetwork, lineProduct, normalizeLineName(lineName),
-                                        lineComment, lineAttrs.toArray(new Line.Attr[0]));
-
-                                final Location direction;
-                                if (directionStr != null) {
-                                    final String[] directionPlaceAndName = splitStationName(directionStr);
-                                    direction = new Location(LocationType.ANY, null, directionPlaceAndName[0],
-                                            directionPlaceAndName[1]);
-                                } else {
-                                    direction = null;
-                                }
-
-                                final Stop departure = new Stop(departureLocation, true,
-                                        plannedDepartureTime != 0 ? new Date(plannedDepartureTime) : null,
-                                        predictedDepartureTime != 0 ? new Date(predictedDepartureTime) : null,
-                                        plannedDeparturePosition, predictedDeparturePosition, departureCancelled);
-                                final Stop arrival = new Stop(arrivalLocation, false,
-                                        plannedArrivalTime != 0 ? new Date(plannedArrivalTime) : null,
-                                        predictedArrivalTime != 0 ? new Date(predictedArrivalTime) : null,
-                                        plannedArrivalPosition, predictedArrivalPosition, arrivalCancelled);
-
-                                leg = new Trip.Public(line, direction, departure, arrival, intermediateStops, null,
-                                        disruptionText);
-                            } else {
-                                throw new IllegalStateException("unhandled type: " + type);
-                            }
-                            legs.add(leg);
-                        }
-
-                        final Trip trip = new Trip(connectionId, resDeparture, resArrival, legs, null, null,
-                                (int) numChanges);
-
-                        if (realtimeStatus != 2) // Verbindung fällt aus
-                            trips.add(trip);
-                    }
-
-                    // if result is only one single individual leg, don't query for more
-                    final boolean canQueryMore = trips.size() != 1 || trips.get(0).legs.size() != 1
-                            || !(trips.get(0).legs.get(0) instanceof Trip.Individual);
-
-                    result.set(new QueryTripsResult(header, url.toString(), from, via, to,
-                            new QueryTripsBinaryContext(requestId, seqNr, ld, bis.getCount(), canQueryMore), trips));
-                } else {
-                    log.debug("Hafas error: {}", errorCode);
-                    if (errorCode == 1) {
-                        throw new SessionExpiredException();
-                    } else if (errorCode == 2) {
-                        // F2: Your search results could not be stored internally.
-                        throw new SessionExpiredException();
-                    } else if (errorCode == 8) {
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.AMBIGUOUS));
-                        return;
-                    } else if (errorCode == 13) {
-                        // IN13: Our booking system is currently being used by too many users at the same
-                        // time.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                        return;
-                    } else if (errorCode == 19) {
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                        return;
-                    } else if (errorCode == 207) {
-                        // H207: Unfortunately your connection request can currently not be processed.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                        return;
-                    } else if (errorCode == 887) {
-                        // H887: Your inquiry was too complex. Please try entering less intermediate stations.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 890) {
-                        // H890: No connections have been found that correspond to your request. It is
-                        // possible
-                        // that the requested service does not operate from or to the places you stated on the
-                        // requested date of travel.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 891) {
-                        // H891: Unfortunately there was no route found. Missing timetable data could be the
-                        // reason.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 892) {
-                        // H892: Your inquiry was too complex. Please try entering less intermediate stations.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 899) {
-                        // H899: there was an unsuccessful or incomplete search due to a timetable change.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 900) {
-                        // Unsuccessful or incomplete search (timetable change)
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 9220) {
-                        // H9220: Nearby to the given address stations could not be found.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNRESOLVABLE_ADDRESS));
-                        return;
-                    } else if (errorCode == 9240) {
-                        // H9240: Unfortunately there was no route found. Perhaps your start or destination is
-                        // not
-                        // served at all or with the selected means of transport on the required date/time.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.NO_TRIPS));
-                        return;
-                    } else if (errorCode == 9260) {
-                        // H9260: Unknown departure station
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_FROM));
-                        return;
-                    } else if (errorCode == 9280) {
-                        // H9280: Unknown intermediate station
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_VIA));
-                        return;
-                    } else if (errorCode == 9300) {
-                        // H9300: Unknown arrival station
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.UNKNOWN_TO));
-                        return;
-                    } else if (errorCode == 9320) {
-                        // The input is incorrect or incomplete
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
-                        return;
-                    } else if (errorCode == 9360) {
-                        // H9360: Unfortunately your connection request can currently not be processed.
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.INVALID_DATE));
-                        return;
-                    } else if (errorCode == 9380) {
-                        // H9380: Dep./Arr./Intermed. or equivalent station defined more than once
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
-                        return;
-                    } else if (errorCode == 895) {
-                        // H895: Departure/Arrival are too near
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.TOO_CLOSE));
-                        return;
-                    } else if (errorCode == 65535) {
-                        result.set(new QueryTripsResult(header, QueryTripsResult.Status.SERVICE_DOWN));
-                        return;
-                    } else {
-                        throw new IllegalStateException("error " + errorCode + " on " + url);
-                    }
-                }
-            }
-        }, url);
-
-        return result.get();
-    }
-
-    private Location location(final LittleEndianDataInputStream is, final StringTable strings) throws IOException {
-        final String name = strings.read(is);
-        is.readShort();
-        final int type = is.readShortReverse();
-        final int lon = is.readIntReverse();
-        final int lat = is.readIntReverse();
-
-        if (type == 1) {
-            final String[] placeAndName = splitStationName(name);
-            return new Location(LocationType.STATION, null, lat, lon, placeAndName[0], placeAndName[1]);
-        } else if (type == 2) {
-            final String[] placeAndName = splitAddress(name);
-            return new Location(LocationType.ADDRESS, null, lat, lon, placeAndName[0], placeAndName[1]);
-        } else if (type == 3) {
-            final String[] placeAndName = splitPOI(name);
-            return new Location(LocationType.POI, null, lat, lon, placeAndName[0], placeAndName[1]);
-        } else {
-            throw new IllegalStateException("unknown type: " + type + "  " + name);
-        }
-    }
-
-    private long date(final LittleEndianDataInputStream is) throws IOException {
-        final int days = is.readShortReverse();
-
-        final Calendar date = new GregorianCalendar(timeZone);
-        date.clear();
-        date.set(Calendar.YEAR, 1980);
-        date.set(Calendar.DAY_OF_YEAR, days);
-
-        return date.getTimeInMillis();
-    }
-
-    private long time(final LittleEndianDataInputStream is, final long baseDate, final int dayOffset)
-            throws IOException {
-        final int value = is.readShortReverse();
-        if (value == 0xffff)
-            return 0;
-
-        final int hours = value / 100;
-        final int minutes = value % 100;
-
-        if (minutes < 0 || minutes > 60)
-            throw new IllegalStateException("minutes out of range: " + minutes);
-
-        final Calendar time = new GregorianCalendar(timeZone);
-
-        time.setTimeInMillis(baseDate);
-        if (time.get(Calendar.HOUR) != 0 || time.get(Calendar.MINUTE) != 0)
-            throw new IllegalStateException("baseDate not on date boundary: " + baseDate);
-
-        time.add(Calendar.DAY_OF_YEAR, dayOffset);
-
-        time.set(Calendar.HOUR, hours);
-        time.set(Calendar.MINUTE, minutes);
-
-        return time.getTimeInMillis();
-    }
-
-    private static class StringTable {
-        private Charset encoding = Charsets.US_ASCII;
-        private final byte[] table;
-
-        public StringTable(final DataInputStream is, final int stringTablePtr, final int length) throws IOException {
-            is.reset();
-            is.skipBytes(stringTablePtr);
-            table = new byte[length];
-            is.readFully(table);
-        }
-
-        public void setEncoding(final Charset encoding) {
-            this.encoding = encoding;
-        }
-
-        public String read(final LittleEndianDataInputStream is) throws IOException {
-            final int pointer = is.readShortReverse();
-            if (pointer == 0)
-                return null;
-            if (pointer >= table.length)
-                throw new IllegalStateException(
-                        "pointer " + pointer + " cannot exceed strings table size " + table.length);
-
-            final InputStreamReader reader = new InputStreamReader(
-                    new ByteArrayInputStream(table, pointer, table.length - pointer), encoding);
-
-            try {
-                final StringBuilder builder = new StringBuilder();
-
-                int c;
-                while ((c = reader.read()) != 0)
-                    builder.append((char) c);
-
-                return builder.toString().trim();
-            } finally {
-                reader.close();
-            }
-        }
-    }
-
-    private static class CommentTable {
-        private final StringTable strings;
-        private final byte[] table;
-
-        public CommentTable(final DataInputStream is, final int commentTablePtr, final int length,
-                final StringTable strings) throws IOException {
-            is.reset();
-            is.skipBytes(commentTablePtr);
-            table = new byte[length];
-            is.readFully(table);
-
-            this.strings = strings;
-        }
-
-        public String[] read(final LittleEndianDataInputStream is) throws IOException {
-            final int pointer = is.readShortReverse();
-            if (pointer >= table.length)
-                throw new IllegalStateException(
-                        "pointer " + pointer + " cannot exceed comments table size " + table.length);
-
-            final LittleEndianDataInputStream commentsInputStream = new LittleEndianDataInputStream(
-                    new ByteArrayInputStream(table, pointer, table.length - pointer));
-
-            try {
-                final int numComments = commentsInputStream.readShortReverse();
-                final String[] comments = new String[numComments];
-
-                for (int i = 0; i < numComments; i++)
-                    comments[i] = strings.read(commentsInputStream);
-
-                return comments;
-            } finally {
-                commentsInputStream.close();
-            }
-        }
-    }
-
-    private class StationTable {
-        private final StringTable strings;
-        private final byte[] table;
-
-        public StationTable(final DataInputStream is, final int stationTablePtr, final int length,
-                final StringTable strings) throws IOException {
-            is.reset();
-            is.skipBytes(stationTablePtr);
-            table = new byte[length];
-            is.readFully(table);
-
-            this.strings = strings;
-        }
-
-        private Location read(final LittleEndianDataInputStream is) throws IOException {
-            final int index = is.readShortReverse();
-            final int ptr = index * 14;
-            if (ptr >= table.length)
-                throw new IllegalStateException(
-                        "pointer " + ptr + " cannot exceed stations table size " + table.length);
-
-            final LittleEndianDataInputStream stationInputStream = new LittleEndianDataInputStream(
-                    new ByteArrayInputStream(table, ptr, 14));
-
-            try {
-                final String[] placeAndName = splitStationName(strings.read(stationInputStream));
-                final int id = stationInputStream.readIntReverse();
-                final int lon = stationInputStream.readIntReverse();
-                final int lat = stationInputStream.readIntReverse();
-
-                return new Location(LocationType.STATION, id != 0 ? Integer.toString(id) : null, lat, lon,
-                        placeAndName[0], placeAndName[1]);
-            } finally {
-                stationInputStream.close();
-            }
-        }
-    }
-
     private static final Pattern P_POSITION_PLATFORM = Pattern.compile("Gleis\\s*(.*)\\s*", Pattern.CASE_INSENSITIVE);
 
-    private Position normalizePosition(final String position) {
+    protected Position normalizePosition(final String position) {
         if (position == null)
             return null;
 
@@ -2935,863 +148,12 @@ public abstract class AbstractHafasProvider extends AbstractNetworkProvider {
         return parsePosition(m.group(1));
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return nearbyLocationsByCoordinate(types, location.lat, location.lon, maxDistance, maxLocations);
-        else if (location.type == LocationType.STATION && location.hasId())
-            return nearbyStationsById(location.id, maxDistance);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
+    protected final StationDepartures findStationDepartures(final List<StationDepartures> stationDepartures,
+            final Location location) {
+        for (final StationDepartures stationDeparture : stationDepartures)
+            if (stationDeparture.location.equals(location))
+                return stationDeparture;
 
-    protected final NearbyLocationsResult nearbyLocationsByCoordinate(final EnumSet<LocationType> types, final int lat,
-            final int lon, final int maxDistance, final int maxLocations) throws IOException {
-        if (types.contains(LocationType.STATION)) {
-            final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage + "y");
-            appendJsonNearbyStationsParameters(url, lat, lon, maxDistance, maxLocations);
-            return jsonNearbyLocations(url.build());
-        } else if (types.contains(LocationType.POI)) {
-            final HttpUrl.Builder url = queryEndpoint.newBuilder().addPathSegment(apiLanguage + "y");
-            appendJsonNearbyPOIsParameters(url, lat, lon, maxDistance, maxLocations);
-            return jsonNearbyLocations(url.build());
-        } else {
-            return new NearbyLocationsResult(null, Collections.<Location> emptyList());
-        }
-    }
-
-    protected NearbyLocationsResult nearbyStationsById(final String id, final int maxDistance) throws IOException {
-        final HttpUrl.Builder url = stationBoardEndpoint.newBuilder().addPathSegment(apiLanguage);
-        appendXmlNearbyStationsParameters(url, id);
-        return xmlNearbyStations(url.build());
-    }
-
-    protected final void appendXmlNearbyStationsParameters(final HttpUrl.Builder url, final String stationId) {
-        url.addQueryParameter("productsFilter", allProductsString().toString());
-        url.addQueryParameter("boardType", "dep");
-        url.addEncodedQueryParameter("input", ParserUtils.urlEncode(normalizeStationId(stationId), requestUrlEncoding));
-        url.addQueryParameter("sTI", "1");
-        url.addQueryParameter("start", "yes");
-        url.addQueryParameter("hcount", "0");
-        url.addQueryParameter("L", "vs_java3");
-        if (clientType != null)
-            url.addEncodedQueryParameter("clientType", ParserUtils.urlEncode(clientType, requestUrlEncoding));
-    }
-
-    private static final Pattern P_XML_NEARBY_STATIONS_COARSE = Pattern.compile("\\G<\\s*St\\s*(.*?)/?>(?:\n|\\z)",
-            Pattern.DOTALL);
-    private static final Pattern P_XML_NEARBY_STATIONS_FINE = Pattern.compile(
-            "" //
-                    + "evaId=\"(\\d+)\"\\s*" // id
-                    + "name=\"([^\"]+)\".*?" // name
-                    + "(?:x=\"(\\d+)\"\\s*)?" // x
-                    + "(?:y=\"(\\d+)\"\\s*)?" // y
-            , Pattern.DOTALL);
-    private static final Pattern P_XML_NEARBY_STATIONS_MESSAGES = Pattern
-            .compile("<Err code=\"([^\"]*)\" text=\"([^\"]*)\"");
-
-    protected final NearbyLocationsResult xmlNearbyStations(final HttpUrl url) throws IOException {
-        // scrape page
-        final CharSequence page = httpClient.get(url);
-
-        final List<Location> stations = new ArrayList<Location>();
-
-        // parse page
-        final Matcher mMessage = P_XML_NEARBY_STATIONS_MESSAGES.matcher(page);
-        if (mMessage.find()) {
-            final String code = mMessage.group(1);
-            final String text = mMessage.group(2);
-
-            if (code.equals("H730")) // Your input is not valid
-                return new NearbyLocationsResult(null, NearbyLocationsResult.Status.INVALID_ID);
-            if (code.equals("H890")) // No trains in result
-                return new NearbyLocationsResult(null, stations);
-            throw new IllegalArgumentException("unknown error " + code + ", " + text);
-        }
-
-        final Matcher mCoarse = P_XML_NEARBY_STATIONS_COARSE.matcher(page);
-        while (mCoarse.find()) {
-            final Matcher mFine = P_XML_NEARBY_STATIONS_FINE.matcher(mCoarse.group(1));
-            if (mFine.matches()) {
-                final String parsedId = mFine.group(1);
-
-                final String parsedName = ParserUtils.resolveEntities(mFine.group(2)).trim();
-
-                final int parsedLon;
-                final int parsedLat;
-                if (mFine.group(3) != null && mFine.group(4) != null) {
-                    parsedLon = Integer.parseInt(mFine.group(3));
-                    parsedLat = Integer.parseInt(mFine.group(4));
-                } else {
-                    parsedLon = 0;
-                    parsedLat = 0;
-                }
-
-                final String[] placeAndName = splitStationName(parsedName);
-                stations.add(new Location(LocationType.STATION, parsedId, parsedLat, parsedLon, placeAndName[0],
-                        placeAndName[1]));
-            } else {
-                throw new IllegalArgumentException("cannot parse '" + mCoarse.group(1) + "' on " + url);
-            }
-        }
-
-        return new NearbyLocationsResult(null, stations);
-    }
-
-    protected void appendJsonNearbyStationsParameters(final HttpUrl.Builder url, final int lat, final int lon,
-            final int maxDistance, final int maxStations) {
-        url.addQueryParameter("performLocating", "2");
-        url.addQueryParameter("tpl", "stop2json");
-        url.addQueryParameter("look_stopclass", Integer.toString(allProductsInt()));
-        url.addQueryParameter("look_nv", "get_stopweight|yes");
-        // get_shortjson|yes
-        // get_lines|yes
-        // combinemode|2
-        // density|80
-        // get_stopweight|yes
-        // get_infotext|yes
-        url.addQueryParameter("look_x", Integer.toString(lon));
-        url.addQueryParameter("look_y", Integer.toString(lat));
-        url.addQueryParameter("look_maxno", Integer.toString(maxStations != 0 ? maxStations : 200));
-        url.addQueryParameter("look_maxdist", Integer.toString(maxDistance != 0 ? maxDistance : 5000));
-    }
-
-    protected void appendJsonNearbyPOIsParameters(final HttpUrl.Builder url, final int lat, final int lon,
-            final int maxDistance, final int maxStations) {
-        url.addQueryParameter("performLocating", "4");
-        url.addQueryParameter("tpl", "poi2json");
-        url.addQueryParameter("look_pois", ""); // all categories
-        url.addQueryParameter("look_x", Integer.toString(lon));
-        url.addQueryParameter("look_y", Integer.toString(lat));
-        url.addQueryParameter("look_maxno", Integer.toString(maxStations != 0 ? maxStations : 200));
-        url.addQueryParameter("look_maxdist", Integer.toString(maxDistance != 0 ? maxDistance : 5000));
-    }
-
-    protected final NearbyLocationsResult jsonNearbyLocations(final HttpUrl url) throws IOException {
-        final CharSequence page = httpClient.get(url);
-
-        try {
-            final JSONObject head = new JSONObject(page.toString());
-            final int error = head.getInt("error");
-            if (error == 0) {
-                final List<Location> locations = new LinkedList<Location>();
-
-                final JSONArray aStops = head.optJSONArray("stops");
-                if (aStops != null) {
-                    final int nStops = aStops.length();
-
-                    for (int i = 0; i < nStops; i++) {
-                        final JSONObject stop = aStops.optJSONObject(i);
-                        final String id = stop.getString("extId");
-                        // final String name = ParserUtils.resolveEntities(stop.getString("name"));
-                        final String urlname = ParserUtils.urlDecode(stop.getString("urlname"),
-                                jsonNearbyLocationsEncoding);
-                        final int lat = stop.getInt("y");
-                        final int lon = stop.getInt("x");
-                        final int prodclass = stop.optInt("prodclass", -1);
-                        final int stopWeight = stop.optInt("stopweight", -1);
-
-                        if (stopWeight != 0) {
-                            final String[] placeAndName = splitStationName(urlname);
-                            final Set<Product> products = prodclass != -1 ? intToProducts(prodclass) : null;
-                            locations.add(new Location(LocationType.STATION, id, lat, lon, placeAndName[0],
-                                    placeAndName[1], products));
-                        }
-                    }
-                }
-
-                final JSONArray aPOIs = head.optJSONArray("pois");
-                if (aPOIs != null) {
-                    final int nPOIs = aPOIs.length();
-
-                    for (int i = 0; i < nPOIs; i++) {
-                        final JSONObject poi = aPOIs.optJSONObject(i);
-                        final String id = poi.getString("extId");
-                        // final String name = ParserUtils.resolveEntities(stop.getString("name"));
-                        final String urlname = ParserUtils.urlDecode(poi.getString("urlname"),
-                                jsonNearbyLocationsEncoding);
-                        final int lat = poi.getInt("y");
-                        final int lon = poi.getInt("x");
-
-                        final String[] placeAndName = splitPOI(urlname);
-                        locations.add(new Location(LocationType.POI, id, lat, lon, placeAndName[0], placeAndName[1]));
-                    }
-                }
-
-                return new NearbyLocationsResult(null, locations);
-            } else {
-                log.debug("Hafas error: {}", error);
-                if (error == 2)
-                    return new NearbyLocationsResult(null, NearbyLocationsResult.Status.SERVICE_DOWN);
-                else
-                    throw new RuntimeException("unknown error: " + error);
-            }
-        } catch (final JSONException x) {
-            x.printStackTrace();
-            throw new RuntimeException("cannot parse: '" + page + "' on " + url, x);
-        }
-    }
-
-    protected AbstractHafasProvider setHtmlNearbyStationsPattern(final Pattern htmlNearbyStationsPattern) {
-        this.htmlNearbyStationsPattern = htmlNearbyStationsPattern;
-        return this;
-    }
-
-    private Pattern htmlNearbyStationsPattern = Pattern.compile("<tr class=\"(zebra[^\"]*)\">(.*?)</tr>",
-            Pattern.DOTALL);
-
-    private static final Pattern P_HTML_NEARBY_FINE_COORDS = Pattern
-            .compile("REQMapRoute0\\.Location0\\.X=(-?\\d+)&(?:amp;)?REQMapRoute0\\.Location0\\.Y=(-?\\d+)&");
-    private static final Pattern P_HTML_NEARBY_STATIONS_FINE_LOCATION = Pattern
-            .compile("[\\?&;]input=(\\d+)&[^\"]*\">([^<]*)<");
-    private static final Pattern P_HTML_NEARBY_STATIONS_MESSAGES = Pattern
-            .compile("(Ihre Eingabe kann nicht interpretiert werden)");
-
-    protected final NearbyLocationsResult htmlNearbyStations(final HttpUrl url) throws IOException {
-        final List<Location> stations = new ArrayList<Location>();
-
-        final CharSequence page = httpClient.get(url);
-        String oldZebra = null;
-
-        final Matcher mCoarse = htmlNearbyStationsPattern.matcher(page);
-
-        final Matcher mMessage = P_HTML_NEARBY_STATIONS_MESSAGES.matcher(page);
-        if (mMessage.find()) {
-            if (mMessage.group(1) != null)
-                return new NearbyLocationsResult(null, NearbyLocationsResult.Status.INVALID_ID);
-        }
-
-        while (mCoarse.find()) {
-            final String zebra = mCoarse.group(1);
-            if (oldZebra != null && zebra.equals(oldZebra))
-                throw new IllegalArgumentException("missed row? last:" + zebra);
-            else
-                oldZebra = zebra;
-
-            final Matcher mFineLocation = P_HTML_NEARBY_STATIONS_FINE_LOCATION.matcher(mCoarse.group(2));
-
-            if (mFineLocation.find()) {
-                int parsedLon = 0;
-                int parsedLat = 0;
-                final String parsedId = mFineLocation.group(1);
-                final String parsedName = ParserUtils.resolveEntities(mFineLocation.group(2));
-
-                final Matcher mFineCoords = P_HTML_NEARBY_FINE_COORDS.matcher(mCoarse.group(2));
-
-                if (mFineCoords.find()) {
-                    parsedLon = Integer.parseInt(mFineCoords.group(1));
-                    parsedLat = Integer.parseInt(mFineCoords.group(2));
-                }
-
-                final String[] placeAndName = splitStationName(parsedName);
-                stations.add(new Location(LocationType.STATION, parsedId, parsedLat, parsedLon, placeAndName[0],
-                        placeAndName[1]));
-            } else {
-                throw new IllegalArgumentException("cannot parse '" + mCoarse.group(2) + "' on " + url);
-            }
-        }
-
-        return new NearbyLocationsResult(null, stations);
-    }
-
-    private static final Pattern P_LINE_SBAHN = Pattern.compile("SN?\\d*");
-    private static final Pattern P_LINE_TRAM = Pattern.compile("STR\\w{0,5}");
-    private static final Pattern P_LINE_BUS = Pattern.compile("BUS\\w{0,5}");
-    private static final Pattern P_LINE_TAXI = Pattern.compile("TAX\\w{0,5}");
-
-    protected Product normalizeType(final String type) {
-        final String ucType = type.toUpperCase();
-
-        // Intercity
-        if ("EC".equals(ucType)) // EuroCity
-            return Product.HIGH_SPEED_TRAIN;
-        if ("EN".equals(ucType)) // EuroNight
-            return Product.HIGH_SPEED_TRAIN;
-        if ("D".equals(ucType)) // EuroNight, Sitzwagenabteil
-            return Product.HIGH_SPEED_TRAIN;
-        if ("EIC".equals(ucType)) // Ekspres InterCity, Polen
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ICE".equals(ucType)) // InterCityExpress
-            return Product.HIGH_SPEED_TRAIN;
-        if ("IC".equals(ucType)) // InterCity
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ICT".equals(ucType)) // InterCity
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ICN".equals(ucType)) // InterCityNight
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ICD".equals(ucType)) // Intercity direkt Amsterdam-Breda
-            return Product.HIGH_SPEED_TRAIN;
-        if ("CNL".equals(ucType)) // CityNightLine
-            return Product.HIGH_SPEED_TRAIN;
-        if ("MT".equals(ucType)) // Schnee-Express
-            return Product.HIGH_SPEED_TRAIN;
-        if ("OEC".equals(ucType)) // ÖBB-EuroCity
-            return Product.HIGH_SPEED_TRAIN;
-        if ("OIC".equals(ucType)) // ÖBB-InterCity
-            return Product.HIGH_SPEED_TRAIN;
-        if ("RJ".equals(ucType)) // RailJet, Österreichische Bundesbahnen
-            return Product.HIGH_SPEED_TRAIN;
-        if ("WB".equals(ucType)) // westbahn
-            return Product.HIGH_SPEED_TRAIN;
-        if ("THA".equals(ucType)) // Thalys
-            return Product.HIGH_SPEED_TRAIN;
-        if ("TGV".equals(ucType)) // Train à Grande Vitesse
-            return Product.HIGH_SPEED_TRAIN;
-        if ("DNZ".equals(ucType)) // Nacht-Schnellzug
-            return Product.HIGH_SPEED_TRAIN;
-        if ("AIR".equals(ucType)) // Generic Flight
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ECB".equals(ucType)) // EC, Verona-München
-            return Product.HIGH_SPEED_TRAIN;
-        if ("LYN".equals(ucType)) // Dänemark
-            return Product.HIGH_SPEED_TRAIN;
-        if ("NZ".equals(ucType)) // Schweden, Nacht
-            return Product.HIGH_SPEED_TRAIN;
-        if ("INZ".equals(ucType)) // Nacht
-            return Product.HIGH_SPEED_TRAIN;
-        if ("RHI".equals(ucType)) // ICE
-            return Product.HIGH_SPEED_TRAIN;
-        if ("RHT".equals(ucType)) // TGV
-            return Product.HIGH_SPEED_TRAIN;
-        if ("TGD".equals(ucType)) // TGV
-            return Product.HIGH_SPEED_TRAIN;
-        if ("IRX".equals(ucType)) // IC
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ES".equals(ucType)) // Eurostar Italia
-            return Product.HIGH_SPEED_TRAIN;
-        if ("EST".equals(ucType)) // Eurostar Frankreich
-            return Product.HIGH_SPEED_TRAIN;
-        if ("EM".equals(ucType)) // Euromed, Barcelona-Alicante, Spanien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("A".equals(ucType)) // Spain, Highspeed
-            return Product.HIGH_SPEED_TRAIN;
-        if ("AVE".equals(ucType)) // Alta Velocidad Española, Spanien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ARC".equals(ucType)) // Arco (Renfe), Spanien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ALS".equals(ucType)) // Alaris (Renfe), Spanien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("ATR".equals(ucType)) // Altaria (Renfe), Spanien
-            return Product.REGIONAL_TRAIN;
-        if ("TAL".equals(ucType)) // Talgo, Spanien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("TLG".equals(ucType)) // Spanien, Madrid
-            return Product.HIGH_SPEED_TRAIN;
-        if ("HOT".equals(ucType)) // Spanien, Nacht
-            return Product.HIGH_SPEED_TRAIN;
-        if ("X2".equals(ucType)) // X2000 Neigezug, Schweden
-            return Product.HIGH_SPEED_TRAIN;
-        if ("X".equals(ucType)) // InterConnex
-            return Product.HIGH_SPEED_TRAIN;
-        if ("FYR".equals(ucType)) // Fyra, Amsterdam-Schiphol-Rotterdam
-            return Product.HIGH_SPEED_TRAIN;
-        if ("FYRA".equals(ucType)) // Fyra, Amsterdam-Schiphol-Rotterdam
-            return Product.HIGH_SPEED_TRAIN;
-        if ("SC".equals(ucType)) // SuperCity, Tschechien
-            return Product.HIGH_SPEED_TRAIN;
-        if ("LE".equals(ucType)) // LEO Express, Prag
-            return Product.HIGH_SPEED_TRAIN;
-        if ("FLUG".equals(ucType))
-            return Product.HIGH_SPEED_TRAIN;
-        if ("TLK".equals(ucType)) // Tanie Linie Kolejowe, Polen
-            return Product.HIGH_SPEED_TRAIN;
-        if ("PKP".equals(ucType)) // Polskie Koleje Państwowe (Polnische Staatsbahnen)
-            return Product.HIGH_SPEED_TRAIN;
-        if ("EIP".equals(ucType)) // Express Intercity Premium
-            return Product.HIGH_SPEED_TRAIN;
-        if ("INT".equals(ucType)) // Zürich-Brüssel - Budapest-Istanbul
-            return Product.HIGH_SPEED_TRAIN;
-        if ("HKX".equals(ucType)) // Hamburg-Koeln-Express
-            return Product.HIGH_SPEED_TRAIN;
-        if ("LOC".equals(ucType)) // Locomore
-            return Product.HIGH_SPEED_TRAIN;
-
-        // Regional
-        if ("ZUG".equals(ucType)) // Generic Train
-            return Product.REGIONAL_TRAIN;
-        if ("R".equals(ucType)) // Generic Regional Train
-            return Product.REGIONAL_TRAIN;
-        if ("DPN".equals(ucType)) // Dritter Personen Nahverkehr
-            return Product.REGIONAL_TRAIN;
-        if ("RB".equals(ucType)) // RegionalBahn
-            return Product.REGIONAL_TRAIN;
-        if ("RE".equals(ucType)) // RegionalExpress
-            return Product.REGIONAL_TRAIN;
-        if ("ER".equals(ucType))
-            return Product.REGIONAL_TRAIN;
-        if ("DB".equals(ucType))
-            return Product.REGIONAL_TRAIN;
-        if ("IR".equals(ucType)) // Interregio
-            return Product.REGIONAL_TRAIN;
-        if ("IRE".equals(ucType)) // Interregio Express
-            return Product.REGIONAL_TRAIN;
-        if ("HEX".equals(ucType)) // Harz-Berlin-Express, Veolia
-            return Product.REGIONAL_TRAIN;
-        if ("WFB".equals(ucType)) // Westfalenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("RT".equals(ucType)) // RegioTram
-            return Product.REGIONAL_TRAIN;
-        if ("REX".equals(ucType)) // RegionalExpress, Österreich
-            return Product.REGIONAL_TRAIN;
-        if ("OS".equals(ucType)) // Osobný vlak, Slovakia oder Osobní vlak, Czech Republic
-            return Product.REGIONAL_TRAIN;
-        if ("SP".equals(ucType)) // Spěšný vlak, Czech Republic
-            return Product.REGIONAL_TRAIN;
-        if ("RX".equals(ucType)) // Express, Czech Republic
-            return Product.REGIONAL_TRAIN;
-        if ("EZ".equals(ucType)) // ÖBB ErlebnisBahn
-            return Product.REGIONAL_TRAIN;
-        if ("ARZ".equals(ucType)) // Auto-Reisezug Brig - Iselle di Trasquera
-            return Product.REGIONAL_TRAIN;
-        if ("OE".equals(ucType)) // Ostdeutsche Eisenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("MR".equals(ucType)) // Märkische Regionalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("PE".equals(ucType)) // Prignitzer Eisenbahn GmbH
-            return Product.REGIONAL_TRAIN;
-        if ("NE".equals(ucType)) // NEB Betriebsgesellschaft mbH
-            return Product.REGIONAL_TRAIN;
-        if ("MRB".equals(ucType)) // Mitteldeutsche Regiobahn
-            return Product.REGIONAL_TRAIN;
-        if ("ERB".equals(ucType)) // eurobahn (Keolis Deutschland)
-            return Product.REGIONAL_TRAIN;
-        if ("HLB".equals(ucType)) // Hessische Landesbahn
-            return Product.REGIONAL_TRAIN;
-        if ("VIA".equals(ucType))
-            return Product.REGIONAL_TRAIN;
-        if ("HSB".equals(ucType)) // Harzer Schmalspurbahnen
-            return Product.REGIONAL_TRAIN;
-        if ("OSB".equals(ucType)) // Ortenau-S-Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("VBG".equals(ucType)) // Vogtlandbahn
-            return Product.REGIONAL_TRAIN;
-        if ("AKN".equals(ucType)) // AKN Eisenbahn AG
-            return Product.REGIONAL_TRAIN;
-        if ("OLA".equals(ucType)) // Ostseeland Verkehr
-            return Product.REGIONAL_TRAIN;
-        if ("UBB".equals(ucType)) // Usedomer Bäderbahn
-            return Product.REGIONAL_TRAIN;
-        if ("PEG".equals(ucType)) // Prignitzer Eisenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("NWB".equals(ucType)) // NordWestBahn
-            return Product.REGIONAL_TRAIN;
-        if ("CAN".equals(ucType)) // cantus Verkehrsgesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("BRB".equals(ucType)) // ABELLIO Rail
-            return Product.REGIONAL_TRAIN;
-        if ("SBB".equals(ucType)) // Schweizerische Bundesbahnen
-            return Product.REGIONAL_TRAIN;
-        if ("VEC".equals(ucType)) // vectus Verkehrsgesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("TLX".equals(ucType)) // Trilex (Vogtlandbahn)
-            return Product.REGIONAL_TRAIN;
-        if ("TL".equals(ucType)) // Trilex (Vogtlandbahn)
-            return Product.REGIONAL_TRAIN;
-        if ("HZL".equals(ucType)) // Hohenzollerische Landesbahn
-            return Product.REGIONAL_TRAIN;
-        if ("ABR".equals(ucType)) // Bayerische Regiobahn
-            return Product.REGIONAL_TRAIN;
-        if ("CB".equals(ucType)) // City Bahn Chemnitz
-            return Product.REGIONAL_TRAIN;
-        if ("WEG".equals(ucType)) // Württembergische Eisenbahn-Gesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("NEB".equals(ucType)) // Niederbarnimer Eisenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("ME".equals(ucType)) // metronom Eisenbahngesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("MER".equals(ucType)) // metronom regional
-            return Product.REGIONAL_TRAIN;
-        if ("ALX".equals(ucType)) // Arriva-Länderbahn-Express
-            return Product.REGIONAL_TRAIN;
-        if ("EB".equals(ucType)) // Erfurter Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("EBX".equals(ucType)) // Erfurter Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("VEN".equals(ucType)) // Rhenus Veniro
-            return Product.REGIONAL_TRAIN;
-        if ("BOB".equals(ucType)) // Bayerische Oberlandbahn
-            return Product.REGIONAL_TRAIN;
-        if ("SBS".equals(ucType)) // Städtebahn Sachsen
-            return Product.REGIONAL_TRAIN;
-        if ("SES".equals(ucType)) // Städtebahn Sachsen Express
-            return Product.REGIONAL_TRAIN;
-        if ("EVB".equals(ucType)) // Eisenbahnen und Verkehrsbetriebe Elbe-Weser
-            return Product.REGIONAL_TRAIN;
-        if ("STB".equals(ucType)) // Süd-Thüringen-Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("AG".equals(ucType)) // Ingolstadt-Landshut
-            return Product.REGIONAL_TRAIN;
-        if ("PRE".equals(ucType)) // Pressnitztalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("DBG".equals(ucType)) // Döllnitzbahn GmbH
-            return Product.REGIONAL_TRAIN;
-        if ("SHB".equals(ucType)) // Schleswig-Holstein-Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("NOB".equals(ucType)) // Nord-Ostsee-Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("RTB".equals(ucType)) // Rurtalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("BLB".equals(ucType)) // Berchtesgadener Land Bahn
-            return Product.REGIONAL_TRAIN;
-        if ("NBE".equals(ucType)) // Nordbahn Eisenbahngesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("SOE".equals(ucType)) // Sächsisch-Oberlausitzer Eisenbahngesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("SDG".equals(ucType)) // Sächsische Dampfeisenbahngesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("VE".equals(ucType)) // Lutherstadt Wittenberg
-            return Product.REGIONAL_TRAIN;
-        if ("DAB".equals(ucType)) // Daadetalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("WTB".equals(ucType)) // Wutachtalbahn e.V.
-            return Product.REGIONAL_TRAIN;
-        if ("BE".equals(ucType)) // Grensland-Express
-            return Product.REGIONAL_TRAIN;
-        if ("ARR".equals(ucType)) // Ostfriesland
-            return Product.REGIONAL_TRAIN;
-        if ("HTB".equals(ucType)) // Hörseltalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("FEG".equals(ucType)) // Freiberger Eisenbahngesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("NEG".equals(ucType)) // Norddeutsche Eisenbahngesellschaft Niebüll
-            return Product.REGIONAL_TRAIN;
-        if ("RBG".equals(ucType)) // Regental Bahnbetriebs GmbH
-            return Product.REGIONAL_TRAIN;
-        if ("MBB".equals(ucType)) // Mecklenburgische Bäderbahn Molli
-            return Product.REGIONAL_TRAIN;
-        if ("VEB".equals(ucType)) // Vulkan-Eifel-Bahn Betriebsgesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("LEO".equals(ucType)) // Chiemgauer Lokalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("VX".equals(ucType)) // Vogtland Express
-            return Product.REGIONAL_TRAIN;
-        if ("MSB".equals(ucType)) // Mainschleifenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("P".equals(ucType)) // Kasbachtalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("ÖBA".equals(ucType)) // Öchsle-Bahn Betriebsgesellschaft
-            return Product.REGIONAL_TRAIN;
-        if ("KTB".equals(ucType)) // Kandertalbahn
-            return Product.REGIONAL_TRAIN;
-        if ("ERX".equals(ucType)) // erixx
-            return Product.REGIONAL_TRAIN;
-        if ("ATZ".equals(ucType)) // Autotunnelzug
-            return Product.REGIONAL_TRAIN;
-        if ("ATB".equals(ucType)) // Autoschleuse Tauernbahn
-            return Product.REGIONAL_TRAIN;
-        if ("CAT".equals(ucType)) // City Airport Train
-            return Product.REGIONAL_TRAIN;
-        if ("EXTRA".equals(ucType) || "EXT".equals(ucType)) // Extrazug
-            return Product.REGIONAL_TRAIN;
-        if ("KD".equals(ucType)) // Koleje Dolnośląskie (Niederschlesische Eisenbahn)
-            return Product.REGIONAL_TRAIN;
-        if ("KM".equals(ucType)) // Koleje Mazowieckie
-            return Product.REGIONAL_TRAIN;
-        if ("EX".equals(ucType)) // Polen
-            return Product.REGIONAL_TRAIN;
-        if ("PCC".equals(ucType)) // PCC Rail, Polen
-            return Product.REGIONAL_TRAIN;
-        if ("ZR".equals(ucType)) // ZSR (Slovakian Republic Railways)
-            return Product.REGIONAL_TRAIN;
-        if ("RNV".equals(ucType)) // Rhein-Neckar-Verkehr GmbH
-            return Product.REGIONAL_TRAIN;
-        if ("DWE".equals(ucType)) // Dessau-Wörlitzer Eisenbahn
-            return Product.REGIONAL_TRAIN;
-        if ("BKB".equals(ucType)) // Buckower Kleinbahn
-            return Product.REGIONAL_TRAIN;
-        if ("GEX".equals(ucType)) // Glacier Express
-            return Product.REGIONAL_TRAIN;
-        if ("M".equals(ucType)) // Meridian
-            return Product.REGIONAL_TRAIN;
-        if ("WBA".equals(ucType)) // Waldbahn
-            return Product.REGIONAL_TRAIN;
-        if ("BEX".equals(ucType)) // Bernina Express
-            return Product.REGIONAL_TRAIN;
-        if ("VAE".equals(ucType)) // Voralpen-Express
-            return Product.REGIONAL_TRAIN;
-        if ("OPB".equals(ucType)) // oberpfalzbahn
-            return Product.REGIONAL_TRAIN;
-        if ("OPX".equals(ucType)) // oberpfalz-express
-            return Product.REGIONAL_TRAIN;
-        if ("TER".equals(ucType)) // Transport express régional
-            return Product.REGIONAL_TRAIN;
-        if ("ENO".equals(ucType))
-            return Product.REGIONAL_TRAIN;
-        if ("THU".equals(ucType)) // Thurbo AG
-            return Product.REGIONAL_TRAIN;
-        if ("GW".equals(ucType)) // gwtr.cz
-            return Product.REGIONAL_TRAIN;
-        if ("SE".equals(ucType)) // ABELLIO Rail Mitteldeutschland GmbH
-            return Product.REGIONAL_TRAIN;
-        if ("UEX".equals(ucType)) // Slovenia
-            return Product.REGIONAL_TRAIN;
-
-        // Suburban Trains
-        if (P_LINE_SBAHN.matcher(ucType).matches()) // Generic (Night) S-Bahn
-            return Product.SUBURBAN_TRAIN;
-        if ("S-BAHN".equals(ucType))
-            return Product.SUBURBAN_TRAIN;
-        if ("BSB".equals(ucType)) // Breisgau S-Bahn
-            return Product.SUBURBAN_TRAIN;
-        if ("SWE".equals(ucType)) // Südwestdeutsche Verkehrs-AG, Ortenau-S-Bahn
-            return Product.SUBURBAN_TRAIN;
-        if ("RER".equals(ucType)) // Réseau Express Régional, Frankreich
-            return Product.SUBURBAN_TRAIN;
-        if ("WKD".equals(ucType)) // Warszawska Kolej Dojazdowa (Warsaw Suburban Railway)
-            return Product.SUBURBAN_TRAIN;
-        if ("SKM".equals(ucType)) // Szybka Kolej Miejska Tricity
-            return Product.SUBURBAN_TRAIN;
-        if ("SKW".equals(ucType)) // Szybka Kolej Miejska Warschau
-            return Product.SUBURBAN_TRAIN;
-
-        // Subway
-        if ("U".equals(ucType)) // Generic U-Bahn
-            return Product.SUBWAY;
-        if ("MET".equals(ucType))
-            return Product.SUBWAY;
-        if ("METRO".equals(ucType))
-            return Product.SUBWAY;
-
-        // Tram
-        if (P_LINE_TRAM.matcher(ucType).matches()) // Generic Tram
-            return Product.TRAM;
-        if ("NFT".equals(ucType)) // Niederflur-Tram
-            return Product.TRAM;
-        if ("TRAM".equals(ucType))
-            return Product.TRAM;
-        if ("TRA".equals(ucType))
-            return Product.TRAM;
-        if ("WLB".equals(ucType)) // Wiener Lokalbahnen
-            return Product.TRAM;
-        if ("STRWLB".equals(ucType)) // Wiener Lokalbahnen
-            return Product.TRAM;
-        if ("SCHW-B".equals(ucType)) // Schwebebahn, gilt als "Straßenbahn besonderer Bauart"
-            return Product.TRAM;
-
-        // Bus
-        if (P_LINE_BUS.matcher(ucType).matches()) // Generic Bus
-            return Product.BUS;
-        if ("NFB".equals(ucType)) // Niederflur-Bus
-            return Product.BUS;
-        if ("SEV".equals(ucType)) // Schienen-Ersatz-Verkehr
-            return Product.BUS;
-        if ("BUSSEV".equals(ucType)) // Schienen-Ersatz-Verkehr
-            return Product.BUS;
-        if ("BSV".equals(ucType)) // Bus SEV
-            return Product.BUS;
-        if ("FB".equals(ucType)) // Fernbus? Luxemburg-Saarbrücken
-            return Product.BUS;
-        if ("EXB".equals(ucType)) // Expressbus München-Prag?
-            return Product.BUS;
-        if ("ICB".equals(ucType)) // ÖBB ICBus
-            return Product.BUS;
-        if ("TRO".equals(ucType)) // Trolleybus
-            return Product.BUS;
-        if ("RFB".equals(ucType)) // Rufbus
-            return Product.BUS;
-        if ("RUF".equals(ucType)) // Rufbus
-            return Product.BUS;
-        if (P_LINE_TAXI.matcher(ucType).matches()) // Generic Taxi
-            return Product.BUS;
-        if ("RFT".equals(ucType)) // Ruftaxi
-            return Product.BUS;
-        if ("LT".equals(ucType)) // Linien-Taxi
-            return Product.BUS;
-        if ("NB".equals(ucType)) // Nachtbus Zürich
-            return Product.BUS;
-        if ("POSTBUS".equals(ucType))
-            return Product.BUS;
-
-        // Phone
-        if ("RUFBUS".equals(ucType))
-            return Product.ON_DEMAND;
-        if (ucType.startsWith("AST")) // Anruf-Sammel-Taxi
-            return Product.ON_DEMAND;
-        if (ucType.startsWith("ALT")) // Anruf-Linien-Taxi
-            return Product.ON_DEMAND;
-        if (ucType.startsWith("BUXI")) // Bus-Taxi (Schweiz)
-            return Product.ON_DEMAND;
-        if ("TB".equals(ucType)) // Taxi-Bus?
-            return Product.ON_DEMAND;
-
-        // Ferry
-        if ("SCHIFF".equals(ucType))
-            return Product.FERRY;
-        if ("FÄHRE".equals(ucType))
-            return Product.FERRY;
-        if ("FÄH".equals(ucType))
-            return Product.FERRY;
-        if ("FAE".equals(ucType))
-            return Product.FERRY;
-        if ("SCH".equals(ucType)) // Schiff
-            return Product.FERRY;
-        if ("AS".equals(ucType)) // SyltShuttle
-            return Product.FERRY;
-        if ("AZS".equals(ucType)) // Autozug Sylt Shuttle
-            return Product.FERRY;
-        if ("KAT".equals(ucType)) // Katamaran, e.g. Friedrichshafen - Konstanz
-            return Product.FERRY;
-        if ("BAT".equals(ucType)) // Boots Anlege Terminal?
-            return Product.FERRY;
-        if ("BAV".equals(ucType)) // Boots Anlege?
-            return Product.FERRY;
-
-        // Cable Car
-        if ("SEILBAHN".equals(ucType))
-            return Product.CABLECAR;
-        if ("SB".equals(ucType)) // Seilbahn
-            return Product.CABLECAR;
-        if ("ZAHNR".equals(ucType)) // Zahnradbahn, u.a. Zugspitzbahn
-            return Product.CABLECAR;
-        if ("GB".equals(ucType)) // Gondelbahn
-            return Product.CABLECAR;
-        if ("LB".equals(ucType)) // Luftseilbahn
-            return Product.CABLECAR;
-        if ("FUN".equals(ucType)) // Funiculaire (Standseilbahn)
-            return Product.CABLECAR;
-        if ("SL".equals(ucType)) // Sessel-Lift
-            return Product.CABLECAR;
-
-        // Unknown product
-        if ("E".equals(ucType))
-            return null;
-
-        throw new IllegalStateException("cannot normalize type '" + type + "'");
-    }
-
-    private static final Pattern P_NORMALIZE_LINE_NAME_BUS = Pattern.compile("bus\\s+(.*)", Pattern.CASE_INSENSITIVE);
-    protected static final Pattern P_NORMALIZE_LINE = Pattern
-            .compile("([A-Za-zßÄÅäáàâåéèêíìîÖöóòôÜüúùûØ/]+)[\\s-]*([^#]*).*");
-
-    protected String normalizeLineName(final String lineName) {
-        final Matcher mBus = P_NORMALIZE_LINE_NAME_BUS.matcher(lineName);
-        if (mBus.matches())
-            return mBus.group(1);
-
-        final Matcher m = P_NORMALIZE_LINE.matcher(lineName);
-        if (m.matches())
-            return m.group(1) + m.group(2);
-
-        return lineName;
-    }
-
-    private static final Pattern P_NORMALIZE_LINE_ADMINISTRATION = Pattern.compile("([^_]*)_*");
-
-    private final String normalizeLineAdministration(final String administration) {
-        if (administration == null)
-            return null;
-
-        final Matcher m = P_NORMALIZE_LINE_ADMINISTRATION.matcher(administration);
-        if (m.find())
-            return m.group(1);
-        else
-            return administration;
-    }
-
-    private static final Pattern P_CATEGORY_FROM_NAME = Pattern.compile("([A-Za-zßÄÅäáàâåéèêíìîÖöóòôÜüúùûØ]+).*");
-
-    protected final String categoryFromName(final String lineName) {
-        final Matcher m = P_CATEGORY_FROM_NAME.matcher(lineName);
-        if (m.matches())
-            return m.group(1);
-        else
-            return lineName;
-    }
-
-    private static final Pattern P_NORMALIZE_LINE_BUS = Pattern.compile("(?:Bus|BUS)\\s*(.*)");
-    private static final Pattern P_NORMALIZE_LINE_TRAM = Pattern.compile("(?:Tram|Tra|Str|STR)\\s*(.*)");
-
-    protected Line parseLine(final String type, final String normalizedName, final boolean wheelchairAccess) {
-        if (normalizedName != null) {
-            final Matcher mBus = P_NORMALIZE_LINE_BUS.matcher(normalizedName);
-            if (mBus.matches())
-                return newLine(Product.BUS, mBus.group(1), null);
-
-            final Matcher mTram = P_NORMALIZE_LINE_TRAM.matcher(normalizedName);
-            if (mTram.matches())
-                return newLine(Product.TRAM, mTram.group(1), null);
-        }
-
-        final Product normalizedType = normalizeType(type);
-
-        final Line.Attr[] attrs;
-        if (wheelchairAccess)
-            attrs = new Line.Attr[] { Line.Attr.WHEEL_CHAIR_ACCESS };
-        else
-            attrs = new Line.Attr[0];
-
-        if (normalizedName != null) {
-            final Matcher m = P_NORMALIZE_LINE.matcher(normalizedName);
-            final String strippedLine = m.matches() ? m.group(1) + m.group(2) : normalizedName;
-
-            return newLine(normalizedType, strippedLine, null, attrs);
-        } else {
-            return newLine(normalizedType, null, null, attrs);
-        }
-    }
-
-    protected static final Pattern P_NORMALIZE_LINE_AND_TYPE = Pattern.compile("([^#]*)#(.*)");
-    private static final Pattern P_NORMALIZE_LINE_NUMBER = Pattern.compile("\\d{2,5}");
-
-    protected static final Pattern P_LINE_RUSSIA = Pattern.compile(
-            "\\d{3}(?:AJ|BJ|CJ|DJ|EJ|FJ|GJ|IJ|KJ|LJ|NJ|MJ|OJ|RJ|SJ|TJ|UJ|VJ|ZJ|CH|KH|ZH|EI|JA|JI|MZ|SH|SZ|PC|Y)");
-
-    protected Line parseLineAndType(final String lineAndType) {
-        final Matcher mLineAndType = P_NORMALIZE_LINE_AND_TYPE.matcher(lineAndType);
-        if (mLineAndType.matches()) {
-            final String number = mLineAndType.group(1);
-            final String type = mLineAndType.group(2);
-
-            if (type.length() == 0) {
-                if (number.length() == 0)
-                    return newLine(null, null, null);
-                if (P_NORMALIZE_LINE_NUMBER.matcher(number).matches())
-                    return newLine(null, number, null);
-                if (P_LINE_RUSSIA.matcher(number).matches())
-                    return newLine(Product.REGIONAL_TRAIN, number, null);
-            } else {
-                final Product normalizedType = normalizeType(type);
-                if (normalizedType != null) {
-                    if (normalizedType == Product.BUS) {
-                        final Matcher mBus = P_NORMALIZE_LINE_BUS.matcher(number);
-                        if (mBus.matches())
-                            return newLine(Product.BUS, mBus.group(1), null);
-                    }
-
-                    if (normalizedType == Product.TRAM) {
-                        final Matcher mTram = P_NORMALIZE_LINE_TRAM.matcher(number);
-                        if (mTram.matches())
-                            return newLine(Product.TRAM, mTram.group(1), null);
-                    }
-                }
-
-                return newLine(normalizedType, number.replaceAll("\\s+", ""), null);
-            }
-
-            throw new IllegalStateException(
-                    "cannot normalize type '" + type + "' number '" + number + "' line#type '" + lineAndType + "'");
-        }
-
-        throw new IllegalStateException("cannot normalize line#type '" + lineAndType + "'");
-    }
-
-    protected Line newLine(final Product product, final String normalizedName, final String comment,
-            final Line.Attr... attrs) {
-        return newLine(null, product, normalizedName, comment, attrs);
-    }
-
-    protected Line newLine(final String network, final Product product, final String normalizedName,
-            final String comment, final Line.Attr... attrs) {
-        if (attrs.length == 0) {
-            return new Line(null, network, product, normalizedName, lineStyle(network, product, normalizedName),
-                    comment);
-        } else {
-            final Set<Line.Attr> attrSet = new HashSet<Line.Attr>();
-            for (final Line.Attr attr : attrs)
-                attrSet.add(attr);
-            return new Line(null, network, product, normalizedName, lineStyle(network, product, normalizedName),
-                    attrSet, comment);
-        }
+        return null;
     }
 }
diff --git a/enabler/src/de/schildbach/pte/BahnProvider.java b/enabler/src/de/schildbach/pte/BahnProvider.java
index f1e94835..144f076b 100644
--- a/enabler/src/de/schildbach/pte/BahnProvider.java
+++ b/enabler/src/de/schildbach/pte/BahnProvider.java
@@ -28,7 +28,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public final class BahnProvider extends AbstractHafasProvider {
+public final class BahnProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://reiseauskunft.bahn.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.FERRY,
diff --git a/enabler/src/de/schildbach/pte/BvgProvider.java b/enabler/src/de/schildbach/pte/BvgProvider.java
index 97412da0..1b2afcd1 100644
--- a/enabler/src/de/schildbach/pte/BvgProvider.java
+++ b/enabler/src/de/schildbach/pte/BvgProvider.java
@@ -36,7 +36,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public final class BvgProvider extends AbstractHafasProvider {
+public final class BvgProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://bvg-apps.hafas.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.SUBURBAN_TRAIN, Product.SUBWAY, Product.TRAM, Product.BUS,
             Product.FERRY, Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.ON_DEMAND };
diff --git a/enabler/src/de/schildbach/pte/DsbProvider.java b/enabler/src/de/schildbach/pte/DsbProvider.java
index 89d83bfc..acd21f5e 100644
--- a/enabler/src/de/schildbach/pte/DsbProvider.java
+++ b/enabler/src/de/schildbach/pte/DsbProvider.java
@@ -27,7 +27,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class DsbProvider extends AbstractHafasProvider {
+public class DsbProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://mobil.rejseplanen.dk/mobil-bin/");
     // http://dk.hafas.de/bin/fat/
     // http://mobil.rejseplanen.dk/mobil-bin/
diff --git a/enabler/src/de/schildbach/pte/EireannProvider.java b/enabler/src/de/schildbach/pte/EireannProvider.java
index 4d8d2ffb..18a70eab 100644
--- a/enabler/src/de/schildbach/pte/EireannProvider.java
+++ b/enabler/src/de/schildbach/pte/EireannProvider.java
@@ -38,7 +38,7 @@ import okhttp3.HttpUrl;
  * 
  * @author Andreas Schildbach
  */
-public class EireannProvider extends AbstractHafasProvider {
+public class EireannProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://journeyplanner.buseireann.ie/jp/bin/");
     private static final Product[] PRODUCTS_MAP = { null, null, null, Product.BUS };
 
diff --git a/enabler/src/de/schildbach/pte/InvgProvider.java b/enabler/src/de/schildbach/pte/InvgProvider.java
index 85145bf9..94aaf96d 100644
--- a/enabler/src/de/schildbach/pte/InvgProvider.java
+++ b/enabler/src/de/schildbach/pte/InvgProvider.java
@@ -59,7 +59,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class InvgProvider extends AbstractHafasProvider {
+public class InvgProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://fpa.invg.de/bin/");
     // http://invg.hafas.de/bin/
     private static final Product[] PRODUCTS_MAP = { null, null, null, null, null, null, null, null, null, null };
diff --git a/enabler/src/de/schildbach/pte/LuProvider.java b/enabler/src/de/schildbach/pte/LuProvider.java
index c73a170f..0b6bb423 100644
--- a/enabler/src/de/schildbach/pte/LuProvider.java
+++ b/enabler/src/de/schildbach/pte/LuProvider.java
@@ -28,7 +28,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class LuProvider extends AbstractHafasProvider {
+public class LuProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://mobiliteitszentral.hafas.de/hafas/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS,
diff --git a/enabler/src/de/schildbach/pte/NasaProvider.java b/enabler/src/de/schildbach/pte/NasaProvider.java
index 7bee5858..3f0e066b 100644
--- a/enabler/src/de/schildbach/pte/NasaProvider.java
+++ b/enabler/src/de/schildbach/pte/NasaProvider.java
@@ -34,7 +34,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class NasaProvider extends AbstractHafasProvider {
+public class NasaProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://reiseauskunft.insa.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.TRAM, Product.BUS,
diff --git a/enabler/src/de/schildbach/pte/NriProvider.java b/enabler/src/de/schildbach/pte/NriProvider.java
index 6198bd1a..2c4d6432 100644
--- a/enabler/src/de/schildbach/pte/NriProvider.java
+++ b/enabler/src/de/schildbach/pte/NriProvider.java
@@ -35,7 +35,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class NriProvider extends AbstractHafasProvider {
+public class NriProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://hafas.websrv05.reiseinfo.no/bin/dev/nri/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.BUS,
             Product.TRAM, Product.SUBWAY, Product.FERRY, Product.FERRY, Product.FERRY };
diff --git a/enabler/src/de/schildbach/pte/NsProvider.java b/enabler/src/de/schildbach/pte/NsProvider.java
index b339da41..c0f4e5a3 100644
--- a/enabler/src/de/schildbach/pte/NsProvider.java
+++ b/enabler/src/de/schildbach/pte/NsProvider.java
@@ -32,7 +32,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class NsProvider extends AbstractHafasProvider {
+public class NsProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://hafas.bene-system.com/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.FERRY,
diff --git a/enabler/src/de/schildbach/pte/NvvProvider.java b/enabler/src/de/schildbach/pte/NvvProvider.java
index 97508914..77732019 100644
--- a/enabler/src/de/schildbach/pte/NvvProvider.java
+++ b/enabler/src/de/schildbach/pte/NvvProvider.java
@@ -34,7 +34,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class NvvProvider extends AbstractHafasProvider {
+public class NvvProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://auskunft.nvv.de/auskunft/bin/jp/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY, Product.TRAM, Product.BUS, Product.BUS,
diff --git a/enabler/src/de/schildbach/pte/OebbProvider.java b/enabler/src/de/schildbach/pte/OebbProvider.java
index 75613202..1eeb07f0 100644
--- a/enabler/src/de/schildbach/pte/OebbProvider.java
+++ b/enabler/src/de/schildbach/pte/OebbProvider.java
@@ -32,7 +32,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class OebbProvider extends AbstractHafasProvider {
+public class OebbProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://fahrplan.oebb.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN,
diff --git a/enabler/src/de/schildbach/pte/OoevvProvider.java b/enabler/src/de/schildbach/pte/OoevvProvider.java
index a1db5b78..55166b58 100644
--- a/enabler/src/de/schildbach/pte/OoevvProvider.java
+++ b/enabler/src/de/schildbach/pte/OoevvProvider.java
@@ -17,44 +17,28 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class OoevvProvider extends AbstractHafasProvider {
+public class OoevvProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://verkehrsauskunft.ooevv.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public OoevvProvider(final String jsonApiAuthorization) {
-        super(NetworkId.OOEVV, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_ooevv\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public OoevvProvider(final String apiAuthorization) {
+        super(NetworkId.OOEVV, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_ooevv\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         httpClient.setSslAcceptAllHostnames(true);
     }
 
@@ -91,39 +75,4 @@ public class OoevvProvider extends AbstractHafasProvider {
 
         return super.splitAddress(address);
     }
-
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
 }
diff --git a/enabler/src/de/schildbach/pte/PlProvider.java b/enabler/src/de/schildbach/pte/PlProvider.java
index 9d4d7c61..095dc04a 100644
--- a/enabler/src/de/schildbach/pte/PlProvider.java
+++ b/enabler/src/de/schildbach/pte/PlProvider.java
@@ -29,7 +29,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class PlProvider extends AbstractHafasProvider {
+public class PlProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://rozklad.bilkom.pl/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.BUS, Product.FERRY };
diff --git a/enabler/src/de/schildbach/pte/RtProvider.java b/enabler/src/de/schildbach/pte/RtProvider.java
index acf33068..75e8b841 100644
--- a/enabler/src/de/schildbach/pte/RtProvider.java
+++ b/enabler/src/de/schildbach/pte/RtProvider.java
@@ -27,7 +27,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class RtProvider extends AbstractHafasProvider {
+public class RtProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://railteam.hafas.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.FERRY,
diff --git a/enabler/src/de/schildbach/pte/SbbProvider.java b/enabler/src/de/schildbach/pte/SbbProvider.java
index 810bb0ae..220f796e 100644
--- a/enabler/src/de/schildbach/pte/SbbProvider.java
+++ b/enabler/src/de/schildbach/pte/SbbProvider.java
@@ -27,7 +27,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class SbbProvider extends AbstractHafasProvider {
+public class SbbProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://fahrplan.sbb.ch/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.FERRY, Product.SUBURBAN_TRAIN, Product.BUS,
diff --git a/enabler/src/de/schildbach/pte/SeProvider.java b/enabler/src/de/schildbach/pte/SeProvider.java
index 1de35e07..83c77f85 100644
--- a/enabler/src/de/schildbach/pte/SeProvider.java
+++ b/enabler/src/de/schildbach/pte/SeProvider.java
@@ -31,7 +31,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class SeProvider extends AbstractHafasProvider {
+public class SeProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://reseplanerare.resrobot.se/bin/");
     // http://samtrafiken.hafas.de/bin/
     // http://reseplanerare.resrobot.se/bin/
diff --git a/enabler/src/de/schildbach/pte/SeptaProvider.java b/enabler/src/de/schildbach/pte/SeptaProvider.java
index dc8d4107..b667080f 100644
--- a/enabler/src/de/schildbach/pte/SeptaProvider.java
+++ b/enabler/src/de/schildbach/pte/SeptaProvider.java
@@ -56,7 +56,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class SeptaProvider extends AbstractHafasProvider {
+public class SeptaProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://airs1.septa.org/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.SUBWAY, Product.TRAM, Product.BUS, Product.SUBURBAN_TRAIN };
     private static final long PARSER_DAY_ROLLOVER_THRESHOLD_MS = 12 * 60 * 60 * 1000;
diff --git a/enabler/src/de/schildbach/pte/ShProvider.java b/enabler/src/de/schildbach/pte/ShProvider.java
index 8c4f525d..49e47085 100644
--- a/enabler/src/de/schildbach/pte/ShProvider.java
+++ b/enabler/src/de/schildbach/pte/ShProvider.java
@@ -17,49 +17,34 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
 import java.util.Currency;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.regex.Matcher;
 
 import javax.annotation.Nullable;
 
-import com.google.common.base.Charsets;
-
 import de.schildbach.pte.dto.Fare;
 import de.schildbach.pte.dto.Fare.Type;
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
 import de.schildbach.pte.dto.Style;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class ShProvider extends AbstractHafasProvider {
+public class ShProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://nah.sh.hafas.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.FERRY,
             Product.SUBWAY, Product.TRAM, Product.ON_DEMAND };
 
-    public ShProvider(final String jsonApiAuthorization) {
-        super(NetworkId.SH, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.10");
-        setJsonApiClient("{\"id\":\"NAHSH\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public ShProvider(final String apiAuthorization) {
+        super(NetworkId.SH, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.10");
+        setApiClient("{\"id\":\"NAHSH\"}");
+        setApiAuthorization(apiAuthorization);
         setStyles(STYLES);
     }
 
@@ -92,41 +77,6 @@ public class ShProvider extends AbstractHafasProvider {
         return super.splitStationName(address);
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
-
     @Override
     protected Fare parseJsonTripFare(final @Nullable String fareSetName, final @Nullable String fareSetDescription,
             String name, final Currency currency, final float price) {
diff --git a/enabler/src/de/schildbach/pte/SncbProvider.java b/enabler/src/de/schildbach/pte/SncbProvider.java
index cd2479ee..7910152c 100644
--- a/enabler/src/de/schildbach/pte/SncbProvider.java
+++ b/enabler/src/de/schildbach/pte/SncbProvider.java
@@ -34,7 +34,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class SncbProvider extends AbstractHafasProvider {
+public class SncbProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://www.belgianrail.be/jp/sncb-nmbs-routeplanner/");
     // http://hari.b-rail.be/hafas/bin/
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, null, Product.HIGH_SPEED_TRAIN, null,
diff --git a/enabler/src/de/schildbach/pte/SvvProvider.java b/enabler/src/de/schildbach/pte/SvvProvider.java
index acd709a6..bec93e0d 100644
--- a/enabler/src/de/schildbach/pte/SvvProvider.java
+++ b/enabler/src/de/schildbach/pte/SvvProvider.java
@@ -17,47 +17,31 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
 import de.schildbach.pte.dto.Style;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class SvvProvider extends AbstractHafasProvider {
+public class SvvProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://fahrplan.salzburg-verkehr.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public SvvProvider(final String jsonApiAuthorization) {
-        super(NetworkId.SVV, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_svv\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public SvvProvider(final String apiAuthorization) {
+        super(NetworkId.SVV, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_svv\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         setStyles(STYLES);
         httpClient.setTrustAllCertificates(true);
     }
@@ -96,41 +80,6 @@ public class SvvProvider extends AbstractHafasProvider {
         return super.splitAddress(address);
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
-
     private static final Map<String, Style> STYLES = new HashMap<String, Style>();
 
     static {
diff --git a/enabler/src/de/schildbach/pte/VaoProvider.java b/enabler/src/de/schildbach/pte/VaoProvider.java
index ae45448a..303540a3 100644
--- a/enabler/src/de/schildbach/pte/VaoProvider.java
+++ b/enabler/src/de/schildbach/pte/VaoProvider.java
@@ -17,47 +17,31 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
 import de.schildbach.pte.dto.Style;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class VaoProvider extends AbstractHafasProvider {
+public class VaoProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://app.verkehrsauskunft.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public VaoProvider(final String jsonApiAuthorization) {
-        super(NetworkId.VAO, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvv\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public VaoProvider(final String apiAuthorization) {
+        super(NetworkId.VAO, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvv\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         setStyles(STYLES);
     }
 
@@ -95,41 +79,6 @@ public class VaoProvider extends AbstractHafasProvider {
         return super.splitAddress(address);
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
-
     private static final Map<String, Style> STYLES = new HashMap<String, Style>();
 
     static {
diff --git a/enabler/src/de/schildbach/pte/VbbProvider.java b/enabler/src/de/schildbach/pte/VbbProvider.java
index 4621a47b..bd61a5a0 100644
--- a/enabler/src/de/schildbach/pte/VbbProvider.java
+++ b/enabler/src/de/schildbach/pte/VbbProvider.java
@@ -32,7 +32,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class VbbProvider extends AbstractHafasProvider {
+public class VbbProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://fahrinfo.vbb.de/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.SUBURBAN_TRAIN, Product.SUBWAY, Product.TRAM, Product.BUS,
             Product.FERRY, Product.HIGH_SPEED_TRAIN, Product.REGIONAL_TRAIN };
diff --git a/enabler/src/de/schildbach/pte/VbnProvider.java b/enabler/src/de/schildbach/pte/VbnProvider.java
index 638d569f..7a5a0710 100644
--- a/enabler/src/de/schildbach/pte/VbnProvider.java
+++ b/enabler/src/de/schildbach/pte/VbnProvider.java
@@ -17,35 +17,21 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
 import de.schildbach.pte.dto.Style;
 import de.schildbach.pte.dto.Style.Shape;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class VbnProvider extends AbstractHafasProvider {
+public class VbnProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://fahrplaner.vbn.de/hafas/");
     // http://fahrplaner.vsninfo.de/hafas/
     // http://fahrplan.rsag-online.de/hafas/
@@ -55,13 +41,11 @@ public class VbnProvider extends AbstractHafasProvider {
             Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.SUBURBAN_TRAIN, Product.BUS, Product.FERRY,
             Product.SUBWAY, Product.TRAM, Product.ON_DEMAND };
 
-    public VbnProvider(final String jsonApiAuthorization) {
-        super(NetworkId.VBN, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.10");
-        setJsonApiClient("{\"id\":\"VBN\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public VbnProvider(final String apiAuthorization) {
+        super(NetworkId.VBN, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.10");
+        setApiClient("{\"id\":\"VBN\"}");
+        setApiAuthorization(apiAuthorization);
         setStyles(STYLES);
     }
 
@@ -92,41 +76,6 @@ public class VbnProvider extends AbstractHafasProvider {
         return Product.ALL;
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
-
     private static final Map<String, Style> STYLES = new HashMap<String, Style>();
 
     static {
diff --git a/enabler/src/de/schildbach/pte/VgsProvider.java b/enabler/src/de/schildbach/pte/VgsProvider.java
index 13a90634..83f90d04 100644
--- a/enabler/src/de/schildbach/pte/VgsProvider.java
+++ b/enabler/src/de/schildbach/pte/VgsProvider.java
@@ -31,7 +31,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class VgsProvider extends AbstractHafasProvider {
+public class VgsProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("http://www.saarfahrplan.de/cgi-bin/");
     // http://www.vgs-online.de/cgi-bin/
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
diff --git a/enabler/src/de/schildbach/pte/VmobilProvider.java b/enabler/src/de/schildbach/pte/VmobilProvider.java
index 02c51170..a0d113c7 100644
--- a/enabler/src/de/schildbach/pte/VmobilProvider.java
+++ b/enabler/src/de/schildbach/pte/VmobilProvider.java
@@ -17,44 +17,28 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class VmobilProvider extends AbstractHafasProvider {
+public class VmobilProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://fahrplan.vmobil.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public VmobilProvider(final String jsonApiAuthorization) {
-        super(NetworkId.VMOBIL, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvv\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public VmobilProvider(final String apiAuthorization) {
+        super(NetworkId.VMOBIL, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvv\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         httpClient.setSslAcceptAllHostnames(true);
     }
 
@@ -91,39 +75,4 @@ public class VmobilProvider extends AbstractHafasProvider {
 
         return super.splitAddress(address);
     }
-
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
 }
diff --git a/enabler/src/de/schildbach/pte/VorProvider.java b/enabler/src/de/schildbach/pte/VorProvider.java
index 3d6af645..fb6ebdd4 100644
--- a/enabler/src/de/schildbach/pte/VorProvider.java
+++ b/enabler/src/de/schildbach/pte/VorProvider.java
@@ -17,47 +17,31 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
 import de.schildbach.pte.dto.Style;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class VorProvider extends AbstractHafasProvider {
+public class VorProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://anachb.vor.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public VorProvider(final String jsonApiAuthorization) {
-        super(NetworkId.VOR, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_anachb\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public VorProvider(final String apiAuthorization) {
+        super(NetworkId.VOR, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_anachb\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         setStyles(STYLES);
     }
 
@@ -95,41 +79,6 @@ public class VorProvider extends AbstractHafasProvider {
         return super.splitAddress(address);
     }
 
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
-
     private static final Map<String, Style> STYLES = new HashMap<String, Style>();
 
     static {
diff --git a/enabler/src/de/schildbach/pte/VvtProvider.java b/enabler/src/de/schildbach/pte/VvtProvider.java
index 51a0721c..bdbd8150 100644
--- a/enabler/src/de/schildbach/pte/VvtProvider.java
+++ b/enabler/src/de/schildbach/pte/VvtProvider.java
@@ -17,44 +17,28 @@
 
 package de.schildbach.pte;
 
-import java.io.IOException;
-import java.util.Date;
-import java.util.EnumSet;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.annotation.Nullable;
-
-import com.google.common.base.Charsets;
-
-import de.schildbach.pte.dto.Location;
-import de.schildbach.pte.dto.LocationType;
-import de.schildbach.pte.dto.NearbyLocationsResult;
 import de.schildbach.pte.dto.Product;
-import de.schildbach.pte.dto.QueryDeparturesResult;
-import de.schildbach.pte.dto.QueryTripsContext;
-import de.schildbach.pte.dto.QueryTripsResult;
-import de.schildbach.pte.dto.SuggestLocationsResult;
 
 import okhttp3.HttpUrl;
 
 /**
  * @author Andreas Schildbach
  */
-public class VvtProvider extends AbstractHafasProvider {
+public class VvtProvider extends AbstractHafasMobileProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://fahrplan.vvt.at/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.SUBURBAN_TRAIN, Product.SUBWAY,
             null, Product.TRAM, Product.REGIONAL_TRAIN, Product.BUS, Product.BUS, Product.TRAM, Product.FERRY,
             Product.ON_DEMAND, Product.BUS, Product.REGIONAL_TRAIN, null, null, null };
 
-    public VvtProvider(final String jsonApiAuthorization) {
-        super(NetworkId.VVT, API_BASE, "dn", PRODUCTS_MAP);
-
-        setJsonApiVersion("1.11");
-        setJsonApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvt\",\"type\":\"AND\"}");
-        setJsonApiAuthorization(jsonApiAuthorization);
-        setJsonNearbyLocationsEncoding(Charsets.UTF_8);
+    public VvtProvider(final String apiAuthorization) {
+        super(NetworkId.VVT, API_BASE, PRODUCTS_MAP);
+        setApiVersion("1.11");
+        setApiClient("{\"id\":\"VAO\",\"l\":\"vs_vvt\",\"type\":\"AND\"}");
+        setApiAuthorization(apiAuthorization);
         httpClient.setSslAcceptAllHostnames(true);
     }
 
@@ -91,39 +75,4 @@ public class VvtProvider extends AbstractHafasProvider {
 
         return super.splitAddress(address);
     }
-
-    @Override
-    public NearbyLocationsResult queryNearbyLocations(final EnumSet<LocationType> types, final Location location,
-            final int maxDistance, final int maxLocations) throws IOException {
-        if (location.hasLocation())
-            return jsonLocGeoPos(types, location.lat, location.lon);
-        else
-            throw new IllegalArgumentException("cannot handle: " + location);
-    }
-
-    @Override
-    public QueryDeparturesResult queryDepartures(final String stationId, final @Nullable Date time,
-            final int maxDepartures, final boolean equivs) throws IOException {
-        return jsonStationBoard(stationId, time, maxDepartures, equivs);
-    }
-
-    @Override
-    public SuggestLocationsResult suggestLocations(final CharSequence constraint) throws IOException {
-        return jsonLocMatch(constraint);
-    }
-
-    @Override
-    public QueryTripsResult queryTrips(final Location from, final @Nullable Location via, final Location to,
-            final Date date, final boolean dep, final @Nullable Set<Product> products,
-            final @Nullable Optimize optimize, final @Nullable WalkSpeed walkSpeed,
-            final @Nullable Accessibility accessibility, final @Nullable Set<Option> options) throws IOException {
-        return jsonTripSearch(from, via, to, date, dep, products, null);
-    }
-
-    @Override
-    public QueryTripsResult queryMoreTrips(final QueryTripsContext context, final boolean later) throws IOException {
-        final JsonContext jsonContext = (JsonContext) context;
-        return jsonTripSearch(jsonContext.from, jsonContext.via, jsonContext.to, jsonContext.date, jsonContext.dep,
-                jsonContext.products, later ? jsonContext.laterContext : jsonContext.earlierContext);
-    }
 }
diff --git a/enabler/src/de/schildbach/pte/ZvvProvider.java b/enabler/src/de/schildbach/pte/ZvvProvider.java
index 37718069..11e12e17 100644
--- a/enabler/src/de/schildbach/pte/ZvvProvider.java
+++ b/enabler/src/de/schildbach/pte/ZvvProvider.java
@@ -36,7 +36,7 @@ import okhttp3.HttpUrl;
 /**
  * @author Andreas Schildbach
  */
-public class ZvvProvider extends AbstractHafasProvider {
+public class ZvvProvider extends AbstractHafasLegacyProvider {
     private static final HttpUrl API_BASE = HttpUrl.parse("https://online.fahrplan.zvv.ch/bin/");
     private static final Product[] PRODUCTS_MAP = { Product.HIGH_SPEED_TRAIN, Product.HIGH_SPEED_TRAIN,
             Product.REGIONAL_TRAIN, Product.REGIONAL_TRAIN, Product.FERRY, Product.SUBURBAN_TRAIN, Product.BUS,
diff --git a/enabler/test/de/schildbach/pte/live/OoevvProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/OoevvProviderLiveTest.java
index 68dad8bd..418a446b 100644
--- a/enabler/test/de/schildbach/pte/live/OoevvProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/OoevvProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class OoevvProviderLiveTest extends AbstractProviderLiveTest {
     public OoevvProviderLiveTest() {
-        super(new OoevvProvider(secretProperty("ooevv.json_api_authorization")));
+        super(new OoevvProvider(secretProperty("ooevv.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/ShProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/ShProviderLiveTest.java
index 4541768b..4707c4cd 100644
--- a/enabler/test/de/schildbach/pte/live/ShProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/ShProviderLiveTest.java
@@ -40,7 +40,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class ShProviderLiveTest extends AbstractProviderLiveTest {
     public ShProviderLiveTest() {
-        super(new ShProvider(secretProperty("sh.json_api_authorization")));
+        super(new ShProvider(secretProperty("sh.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/SvvProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/SvvProviderLiveTest.java
index 898726e1..de9c04b1 100644
--- a/enabler/test/de/schildbach/pte/live/SvvProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/SvvProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class SvvProviderLiveTest extends AbstractProviderLiveTest {
     public SvvProviderLiveTest() {
-        super(new SvvProvider(secretProperty("svv.json_api_authorization")));
+        super(new SvvProvider(secretProperty("svv.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/VaoProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/VaoProviderLiveTest.java
index 87889344..5b678227 100644
--- a/enabler/test/de/schildbach/pte/live/VaoProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/VaoProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class VaoProviderLiveTest extends AbstractProviderLiveTest {
     public VaoProviderLiveTest() {
-        super(new VaoProvider(secretProperty("vao.json_api_authorization")));
+        super(new VaoProvider(secretProperty("vao.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/VbnProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/VbnProviderLiveTest.java
index 70fa5daa..496dc7f8 100644
--- a/enabler/test/de/schildbach/pte/live/VbnProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/VbnProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class VbnProviderLiveTest extends AbstractProviderLiveTest {
     public VbnProviderLiveTest() {
-        super(new VbnProvider(secretProperty("vbn.json_api_authorization")));
+        super(new VbnProvider(secretProperty("vbn.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/VmobilProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/VmobilProviderLiveTest.java
index 633a8e19..c908d653 100644
--- a/enabler/test/de/schildbach/pte/live/VmobilProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/VmobilProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class VmobilProviderLiveTest extends AbstractProviderLiveTest {
     public VmobilProviderLiveTest() {
-        super(new VmobilProvider(secretProperty("vmobil.json_api_authorization")));
+        super(new VmobilProvider(secretProperty("vmobil.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/VorProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/VorProviderLiveTest.java
index b610ec20..d13019be 100644
--- a/enabler/test/de/schildbach/pte/live/VorProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/VorProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class VorProviderLiveTest extends AbstractProviderLiveTest {
     public VorProviderLiveTest() {
-        super(new VorProvider(secretProperty("vor.json_api_authorization")));
+        super(new VorProvider(secretProperty("vor.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/VvtProviderLiveTest.java b/enabler/test/de/schildbach/pte/live/VvtProviderLiveTest.java
index 4e8d1ec1..519d9029 100644
--- a/enabler/test/de/schildbach/pte/live/VvtProviderLiveTest.java
+++ b/enabler/test/de/schildbach/pte/live/VvtProviderLiveTest.java
@@ -42,7 +42,7 @@ import de.schildbach.pte.dto.SuggestLocationsResult;
  */
 public class VvtProviderLiveTest extends AbstractProviderLiveTest {
     public VvtProviderLiveTest() {
-        super(new VvtProvider(secretProperty("vvt.json_api_authorization")));
+        super(new VvtProvider(secretProperty("vvt.api_authorization")));
     }
 
     @Test
diff --git a/enabler/test/de/schildbach/pte/live/secrets.properties.template b/enabler/test/de/schildbach/pte/live/secrets.properties.template
index 3fd13c7b..3a3b7002 100644
--- a/enabler/test/de/schildbach/pte/live/secrets.properties.template
+++ b/enabler/test/de/schildbach/pte/live/secrets.properties.template
@@ -1,8 +1,13 @@
 # Secrets are needed to run some of the live tests.
 vgn.api_base =
 navitia.authorization =
-vbn.json_api_authorization =
-sh.json_api_authorization =
-vao.json_api_authorization =
+vbn.api_authorization =
+sh.api_authorization =
+vor.api_authorization =
+ooevv.api_authorization =
+svv.api_authorization =
+vvt.api_authorization =
+vmobil.api_authorization =
+vao.api_authorization =
 hsl.usertoken =
 hsl.passphrase =