Repository: hudora/pyShipping
Branch: master
Commit: 089c502db5d7
Files: 36
Total size: 310.0 KB

Directory structure:
gitextract_q2tr1ik7/

├── .gitignore
├── CHANGES
├── LICENSE
├── MANIFEST.in
├── Makefile
├── README.rst
├── pyshipping/
│   ├── 3dbpp.c
│   ├── __init__.py
│   ├── addressvalidation.py
│   ├── binpack.py
│   ├── binpack_simple.py
│   ├── carriers/
│   │   ├── __init__.py
│   │   └── dpd/
│   │       ├── __init__.py
│   │       ├── georoute.py
│   │       ├── georoute_test.py
│   │       └── georoutetables/
│   │           ├── COUNTRY
│   │           ├── LOCATION.DE
│   │           ├── LOCATION.EN
│   │           ├── LOCATION.FR
│   │           ├── SERVICE
│   │           ├── SERVICEINFO.CS
│   │           ├── SERVICEINFO.CZ
│   │           ├── SERVICEINFO.DE
│   │           ├── SERVICEINFO.EE
│   │           └── SERVICEINFO.EN
│   ├── fortras/
│   │   ├── __init__.py
│   │   ├── bordero.py
│   │   ├── entl.py
│   │   ├── fakt.py
│   │   ├── fortras_stat.py
│   │   └── test.py
│   ├── package.py
│   └── shipment.py
├── requirements.txt
├── setup.py
└── testdata.txt

================================================
FILE CONTENTS
================================================

================================================
FILE: .gitignore
================================================
*.pyc
*.pyo
*.so
*~
build
dist
html
pyShipping.egg-info
*.bak


================================================
FILE: CHANGES
================================================
1.9:    neue Routeninfos von DPD zum 2011-05-07
1.8:    neue Routeninfos von DPD zum 2011-01-03
1.7:    neue Routeninfos von DPD zum 6.9.2010
1.6:    addressvalidation added
1.5:    Keep Package dimensions sorted, buendelung(), __add__() and hat_gleiche_seiten() 
        added binpacking (c) David Pisinger, Silvano Martello, Daniele Vigo
        and an independent pure Python implementation
        unified PackageSize and Package, made Package sortable
1.4:    Gemeinsame Basisklasse fuer Exceptions in pyshipping.carriers.dpd.georoute
1.3p3:  Added new Routing Table for DPD (Routendatenbank Januar - April 2010)
1.3p2:  Added new Routing Table for DPD
1.3p1:  Provide extra argument basedir to fortras.bordero.ship(). Bordero files will be saved in this directory.


================================================
FILE: LICENSE
================================================
Original code in this disturibution is
Copyright 2008, 2009 HUDORA GmbH. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are
permitted provided that the following conditions are met:

   1. Redistributions of source code must retain the above copyright notice, this list of
      conditions and the following disclaimer.

   2. Redistributions in binary form must reproduce the above copyright notice, this list
      of conditions and the following disclaimer in the documentation and/or other materials
      provided with the distribution.

THIS SOFTWARE IS PROVIDED BY HUDORA GmbH ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

This distribution contains software by third parties which might be licensed differently.
See the respective sourcefiles for details.

================================================
FILE: MANIFEST.in
================================================
include README.rst
include pyshipping/carriers/dpd/georoutetables/*

================================================
FILE: Makefile
================================================
# setting the PATH seems only to work in GNUmake not in BSDmake
PATH := ./testenv/bin:$(PATH)

check:
	pep8 -r --ignore=E501 pyshipping/
	sh -c 'PYTHONPATH=. pyflakes pyshipping/'
	-sh -c 'PYTHONPATH=. pylint -iy --max-line-length=110 pyshipping/' # -rn

build:
	python setup.py build

test:
	PYTHONPATH=. python pyshipping/__init__.py # find import errors
	PYTHONPATH=. python pyshipping/shipment.py
	PYTHONPATH=. python pyshipping/package.py
	PYTHONPATH=. python pyshipping/fortras/test.py
	PYTHONPATH=. python pyshipping/binpack.py
	# These tests tend to fail because of routing table updates
	PYTHONPATH=. python pyshipping/carriers/dpd/georoute_test.py

dependencies:
	virtualenv testenv
	pip -q install -E testenv -r requirements.txt

statistics:
	sloccount --wide --details pyshipping | tee sloccount.sc

upload: build doc
	python setup.py sdist upload

doc: build
	rm -Rf html
	mkdir -p html
	mkdir -p html/fortras
	mkdir -p html/carriers
	sh -c '(cd html; pydoc -w ../pyshipping/*.py)'
	sh -c '(cd html/fortras; pydoc -w ../../pyshipping/*.py)'
	sh -c '(cd html/carriers; pydoc -w ../../pyshipping/*.py)'

install: build
	sudo python setup.py install

clean:
	rm -Rf testenv build dist html test.db pyShipping.egg-info pylint.out sloccount.sc pip-log.txt
	find . -name '*.pyc' -or -name '*.pyo' -delete

.PHONY: test build clean check upload doc install


================================================
FILE: README.rst
================================================
pyShipping provides connections to interface with shipping companies and to transport shipping related information. 

 * package - shipping/cargo related calculations based on a unit of shipping (box, crate, package), includes
   a bin packing implementation in pure Python
 * sendung - defines an abstract shippment (Sendung), with packages and calculations based on that
 * addressvalidation - check if an address is valid
 * carriers.dpd - calculation of DPD/Georoutes routing data and labels. Included tables are for shippments from Wuppertal but it should work with all other german routing tables. See this Blogpost_ about updating routing information.
 * fortras - tools for reading and writing Fortras messages. Fortras is a EDI standard for logistics related information somewhat common in Germany. See Wikipedia_ for further enlightenment

.. _Wikipedia: http://de.wikipedia.org/wiki/Fortras
.. _Blogpost: https://cybernetics.hudora.biz/intern/wordpress/2010/09/dpd-routeninformationen-aktualisieren/

It also comes with the only python based `3D Bin Packing <http://www.cs.sunysb.edu/~algorith/files/bin-packing.shtml>`_ implementation I'm aware of. The Algorithm has sufficient performance to be used in everyday shipping and warehousing applications.

You can get the whole Package at http://pypi.python.org/pypi/pyShipping

This code is BSD Licensed.

.. image:: https://d2weczhvl823v0.cloudfront.net/hudora/pyshipping/trend.png
   :alt: Bitdeli badge
   :target: https://bitdeli.com/free



================================================
FILE: pyshipping/3dbpp.c
================================================

/* ======================================================================
      3D BIN PACKING, Silvano Martello, David Pisinger, Daniele Vigo 
                             1998, 2003, 2006
   ====================================================================== */

/* This code solves the three-dimensional bin-packing problem, which
 * asks for an orthogonal packing of a given set of rectangular-shaped
 * boxes into the minimum number of three-dimensional rectangular bins.
 * Each box j=1,..,n is characterized by a width w_j, height h_j, and
 * depth d_j. An unlimited number of indentical three-dimensional bins,
 * having width W, height H and depth D is available. The boxes have fixed
 * orientation, i.e., they may not be rotated.
 *
 * A description of this code is found in the following papers:
 *
 *   S. Martello, D. Pisinger, D. Vigo, E. den Boef, J. Korst (2003)
 *   "Algorithms for General and Robot-packable Variants of the 
 *    Three-Dimensional Bin Packing Problem"
 *   submitted TOMS.
 * 
 *   S.Martello, D.Pisinger, D.Vigo (2000)
 *   "The three-dimensional bin packing problem"
 *   Operations Research, 48, 256-267
 *
 * The present code is written in ANSI-C, and has been compiled with
 * the GNU-C compiler using option "-ansi -pedantic" as well as the
 * HP-UX C compiler using option "-Aa" (ansi standard).
 *
 * This file contains the callable routine binpack3d with prototype
 *
 *   void binpack3d(int n, int W, int H, int D,
 *                  int *w, int *h, int *d, 
 *                  int *x, int *y, int *z, int *bno,
 *                  int *lb, int *ub, 
 *                  int nodelimit, int iterlimit, int timelimit, 
 *                  int *nodeused, int *iterused, int *timeused);
 *
 * the meaning of the parameters is the following:
 *   n         Size of problem, i.e., number of boxes to be packed.
 *             This value must be smaller than MAXBOXES defined below.
 *   W,H,D     Width, height and depth of every bin.
 *   w,h,d     Integer arrays of length n, where w[j], h[j], d[j]
 *             are the dimensions of box j for j=0,..,n-1.
 *   x,y,z,bno Integer arrays of length n where the solution found
 *             is returned. For each box j=0,..,n-1, the bin number
 *             it is packed into is given by bno[j], and x[j], y[j], z[j] 
 *             are the coordinates of it lower-left-backward corner.
 *   lb        Lower bound on the solution value (returned by the procedure).
 *   ub        Objective value of the solution found, i.e., number of bins
 *             used to pack the n boxes. (returned by the procedure).
 *   nodelimit maximum number of decision nodes to be explored in the
 *             main branching tree. If set to zero, the algorithm will
 *             run until an optimal solution is found (or timelimit or
 *             iterlimit is reached). Measured in thousands (see IUNIT).
 *   iterlimit maximum number of iterations in the ONEBIN algorithm
 *             which packs a single bin. If set to zero, the algorithm will
 *             run until an optimal solution is found (or timelimit or
 *             nodelimit is reached). Measured in thousands (see IUNIT).
 *   timelimit Time limit for solving the problem expressed in seconds.
 *             If set to zero, the algorithm will run until an optimal
 *             solution is found; otherwise it terminates after timelimit
 *             seconds with a heuristic solution. 
 *   nodeused  returns the number of branch-and-bound nodes investigated,
 *             measured in thousands (see IUNIT).
 *   iterused  returns the number of iterations in ONEBIN algorithm,
 *             measured in thousands (see IUNIT).
 *   timeused  returns the time used in miliseconds
 *
 * (c) Copyright 1998, 2003, 2005
 *
 *   David Pisinger                        Silvano Martello, Daniele Vigo
 *   DIKU, University of Copenhagen        DEIS, University of Bologna
 *   Universitetsparken 1                  Viale Risorgimento 2
 *   Copenhagen, Denmark                   Bologna, Italy
 *
 * This code can be used free of charge for research and academic purposes 
 * only. 
 */              

#define IUNIT        1000  /* scaling factor of nodes and iterat */ 
#define MAXBOXES      101  /* max number of boxes (plus one box) */
#define MAXBPP    1000000  /* max numer of iterations in 1-dim bpp */
#define MAXITER      1000  /* max iterations in heuristic onebin_robot */
#define MAXCLOSE       16  /* max level for which try_close is applied */

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
#include <time.h>  
#include <limits.h>


/* ======================================================================
				   macros
   ====================================================================== */

#define TRUE  1           /* logical variables */
#define FALSE 0

#define WDIM  0           /* rotations of boxes */
#define HDIM  1
#define DDIM  2

#define LEFT   0          /* relative placements */
#define RIGHT  1
#define UNDER  2
#define ABOVE  3
#define FRONT  4
#define BEHIND 5
#define UNDEF  6
#define RELMAX 8

#define STACKDEPTH (MAXBOXES*MAXBOXES*RELMAX)

#define VOL(i)            ((i)->w * (ptype) (i)->h * (i)->d)
#define MINIMUM(i,j)      ((i) < (j) ? (i) : (j))
#define MAXIMUM(i,j)      ((i) > (j) ? (i) : (j))
#define DIF(i,j)          ((int) ((j) - (i) + 1))
#define SWAPINT(a,b)      { register int t; t=*(a);*(a)=*(b);*(b)=t; }
#define SWAP(a,b)         { register box t; t=*(a);*(a)=*(b);*(b)=t; }
#define SWAPI(a,b)        { register itype t; t=(a);(a)=(b);(b)=t; }
#define SWAPP(a,b)        { register point t; t=*(a);*(a)=*(b);*(b)=t; }
#define DF(a,b)           ((r=(a).y-(b).y) != 0 ? r : (a).x-(b).x)


/* ======================================================================
				 type declarations
   ====================================================================== */

typedef short         boolean; /* logical variable      */
typedef short         ntype;   /* number of states,bins */
typedef short         itype;   /* can hold up to W,H,D  */
typedef long          stype;   /* can hold up to W*H*D  */
typedef long          ptype;   /* product multiplication */

/* box record */
typedef struct irec {
  ntype    no;           /* box number                            */
  itype    w;            /* box width  (x-size)                   */
  itype    h;            /* box height (y-size)                   */
  itype    d;            /* box depth  (z-size)                   */
  itype    x;            /* optimal x-position                    */
  itype    y;            /* optimal y-position                    */
  itype    z;            /* optimal z-position                    */
  ntype    bno;          /* bin number                            */
  boolean  k;            /* is the box chosen?                    */
  stype    vol;          /* volume of box                         */
  struct irec *ref;      /* reference to original box (if necessary) */
} box; 

/* all problem information */
typedef struct {
  itype    W;            /* x-size of bin                         */
  itype    H;            /* y-size of bin                         */
  itype    D;            /* z-size of bin                         */
  stype    BVOL;         /* volume of a bin                       */
  ntype    n;            /* number of boxes                       */
  box      *fbox;        /* first box in problem                  */
  box      *lbox;        /* last box in problem                   */
  box      *fsol;        /* first box in current solution         */
  box      *lsol;        /* last box in current solution          */
  box      *fopt;        /* first box in optimal solution         */
  box      *lopt;        /* last box in optimal solution          */
  boolean  *closed;      /* for each bin indicator whether closed */
  box      *fclosed;     /* first box in closed bins              */
  box      *lclosed;     /* last box in closed bins               */
  ntype    noc;          /* number of closed bins                 */
  itype    mindim;       /* currently smallest box length         */
  itype    maxdim;       /* currently largest box length          */
  stype    maxfill;      /* the best filling found                */
  int      mcut;         /* how many siblings at each node in b&b */

  /* different bounds */
  ntype    bound0;       /* Bound L_0 at root node                */
  ntype    bound1;       /* Bound L_1 at root node                */
  ntype    bound2;       /* Bound L_2 at root node                */
  ntype    lb;           /* best of the above                     */
  ntype    z;            /* currently best solution               */

  /* controle of 3d filler */
  int      maxiter;      /* max iterations in onebin_robot        */
  int      miss;         /* number boxes not packed in onebin_robot */

  /* debugging and controle information */
  int      nodes;        /* nodes in branch-and-bound             */
  int      iterat;       /* iterations in onebin_decision         */
  int      subnodes;     /* nodes in branch-and-bound             */
  int      subiterat;    /* iterations in onebin_decision         */
  int      exfill;       /* number of calls to onebin_decision    */
  int      iter3d;       /* iterations in onebin_robot or general */
  int      zlayer;       /* heuristic solution layer              */
  int      zmcut;        /* heuristic solution mcut               */
  double   exacttopo;    /* number of topological sorts           */
  double   exacttopn;    /* number of topological sorts           */
  int      exactcall;    /* number of calls to exact              */
  int      exactn;       /* largest problem for exact             */
  double   genertime;    /* time used in onebin_general           */
  double   robottime;    /* time used in onebin_robot             */
  double   time;         /* computing time                        */
  double   lhtime;       /* layer heuristic computing time        */
  double   mhtime;       /* mcut heuristic computing time         */
  int      didpush;      /* did the lower bound push up bound     */
  int      maxclose;     /* max number of closed bins at any time */
  int      nodelimit;    /* maximum number of nodes in main tree  */
  int      iterlimit;    /* maximum number of iterations in ONEBIN*/
  int      timelimit;    /* maximum amount of time to be used     */
} allinfo;

/* structure for greedy algorithm */
typedef struct {
  int      lno;          /* layer number                          */
  int      d;            /* depth of layer                        */
  int      bno;          /* bin no assigned to layer              */
  int      z;            /* z level of layer within bin           */
  int      b;            /* temporary bin number                  */
} heurpair;

/* structure for extreme points in a single bin */
typedef struct {
  itype    x;            /* x-coordinate                          */
  itype    y;            /* y-coordinate                          */
  itype    z;            /* z-coordinate                          */
} point;

/* structure for a domain pair in constraint programming */
typedef struct {
  int i;                 /* index of box i                        */
  int j;                 /* index of box j                        */
  int relation;          /* relation between the two boxes        */
  boolean domain;        /* domain of the two boxes               */
} domainpair;
  

/* set of domains */
typedef char domset[RELMAX];
typedef domset domline[MAXBOXES];

/* pointer to comparison function */
typedef int (*funcptr) (const void *, const void *); 


/* ======================================================================
				  global variables
   ====================================================================== */

/* boolean variable to indicate time-out situation */
boolean stopped; 

/* counter used to ensure that 1D BPP at most performs MAXBPP iterations */
int bpiterat;

/* boolean variables to indicate when 1D packing algorithm should terminate */
boolean feasible, terminate;

/* stack of domain pairs */
domainpair domstack[STACKDEPTH];
domainpair *dompos, *domend; 

/* domain of each box */
domline domain[MAXBOXES];

/* current relation between two boxes */
char relation[MAXBOXES][MAXBOXES];

/* debug variable to see level in recursive packing algorithm */
int bblevel;


/* =======================================================================
				  error
   ======================================================================= */

void error(char *str, ...)
{
  va_list args;

  va_start(args, str);
  vprintf(str, args); printf("\n");
  va_end(args);
  printf("IRREGULAR PROGRAM TERMINATION\n");
  exit(-1);
}


/* **********************************************************************
   **********************************************************************
			     Timing routines 
   **********************************************************************
   ********************************************************************** */

/* This timing routine is based on the ANSI-C procedure "clock", which
 * has a resolution of 1000000 ticks per second. This however implies
 * that we pass the limit of a long integer after only 4295 seconds.
 * The following routine attempts to correct such situations by adding
 * the constant ULONG_MAX to the counter whenever wraparound can be
 * detected. But the user is advised to use a timing routine like "times"
 * (which however is not ANSI-C standard) for measuring longer time
 * periods.
 */

void timer(double *time)
{
  static double tstart, tend, tprev;

  if (time == NULL) {
    clock(); /* one extra call to initialize clock */
    tstart = tprev = clock();
  } else {
    tend = clock(); 
    if (tend < tprev) tstart -= ULONG_MAX; /* wraparound occured */
    tprev = tend;
    *time = (tend-tstart) / CLOCKS_PER_SEC; /* convert to seconds */
  }
}

/* test for time limit */
void check_timelimit(long max)
{
  double t;
  if (max == 0) return;
  timer(&t); 
  if (t >= max) { 
    if (!stopped) printf("TIMELIMIT\n"); 
    stopped = TRUE; 
  }
}

/* test for node limit */
void check_nodelimit(long nodes, long max)
{
  if (max == 0) return;
  if (nodes >= max) { 
    if (!stopped) printf("NODELIMIT\n"); 
    stopped = TRUE; 
  }
}

/* test for iteration limit */
void check_iterlimit(long iterations, long max)
{
  if (max == 0) return;
  if (iterations >= max) { 
    if (!stopped) printf("ITERLIMIT\n"); 
    stopped = TRUE; 
  } 
}



/* **********************************************************************
   **********************************************************************
			     Small procedures
   **********************************************************************
   ********************************************************************** */

/* ======================================================================
			    simple comparisions
   ====================================================================== */

/* Comparisons used as argument to qsort. */

int dcomp(box *a, box *b) 
{ int r; r = b->d - a->d; if (r != 0) return r; else return b->no - a->no; }
int hcomp(box *a, box *b) 
{ int r; r = b->h - a->h; if (r != 0) return r; else return b->no - a->no; }
int vcomp(box *a, box *b) /* volume decr. */
{ int r; r = b->vol-a->vol; if (r != 0) return r; else return b->no - a->no; }
int xcomp(heurpair *a, heurpair *b) /* depth decr. */
{ int r; r = b->d - a->d; if (r != 0) return r; else return b->lno - a->lno; }
int lcomp(heurpair *a, heurpair *b) /* layer number decr. */
{ int r; r = a->lno-b->lno; if (r != 0) return r; else return b->d - a->d; }


/* ======================================================================
				  palloc
   ====================================================================== */

/* Memory allocation and freeing, with implicit check */

void *palloc(long sz, long no)
{
  long size;
  void *p;

  size = sz * no;
  if (size == 0) size = 1;
  p = (void *) malloc(size);
  if (p == NULL) error("no memory size %ld", size);
  return p;
}

void pfree(void *p)
{
  if (p == NULL) error("freeing null");
  free(p);
}


/* ======================================================================
			     checksol
   ====================================================================== */

/* Check correctnes of solution, i.e., no boxes overlap, no duplicated boxes.
 */

void checksol(allinfo *a, box *f, box *l)
{
  box *i, *j, *m;
  for (i = f, m = l+1; i != m; i++) { 
    if (!i->k) continue;  /* box currently not chosen */
    for (j = f; j != m; j++) {
      if (i == j) continue;
      if (i->no == j->no) error("duplicated box %d\n", i->no); 
      if (!j->k) continue;
      if (i->bno != j->bno) continue;
      if ((i->x + i->w > j->x) && (j->x + j->w > i->x) &&
	  (i->y + i->h > j->y) && (j->y + j->h > i->y) &&
	  (i->z + i->d > j->z) && (j->z + j->d > i->z)) {
	error("overlap box %d,%d: [%d,%d,%d] [%d,%d,%d]",
	      i->no, j->no, i->w, i->h, i->d, j->w, j->h, j->d);
      }
    }
  }
}

/* ======================================================================
			       savesol
   ====================================================================== */

/* save an updated solution, checking its validity */

void savesol(allinfo *a, box *f, box *l, ntype z)
{
  box *i, *k, *m;

  /* first check validity */
  if (z >= a->z) error("not improved");
  for (i = f, m = l+1; i != m; i++) {
    if ((1 <= i->bno) && (i->bno <= z)) continue; 
    error("illegal bin %d, box %d", i->bno, i->no); 
  }

  /* now do the saving */
  a->z = z;
  for (i = f, k = a->fopt, m = l+1; i != m; i++, k++) *k = *i;
  for (i = a->fclosed, m = a->lclosed+1; i != m; i++, k++) *k = *i;
  for (i = a->fopt, m = a->lopt+1; i != m; i++) i->k = TRUE;
  if (DIF(a->fopt,k-1) != a->n) error("not correct amount of boxes");
  checksol(a, a->fopt, a->lopt);
}


/* ======================================================================
			       isortincr
   ====================================================================== */

/* A specialized routine for sorting integers in increasing order. */
/* qsort could be used equally well, but this routine is faster. */

void isortincr(int *f, int *l)
{
  register int mi;
  register int *i, *j, *m;
  register int d;

  d = l - f + 1;
  if (d < 1) error("negative interval in isortincr");
  if (d == 1) return;
  m = f + d / 2; if (*f > *m) SWAPINT(f, m);
  if (d > 2) { if (*m > *l) { SWAPINT(m, l); if (*f > *m) SWAPINT(f, m); } }
  if (d <= 3) return;
  mi = *m; i = f; j = l;
  for (;;) {
    do i++; while (*i < mi);
    do j--; while (*j > mi);
    if (i > j) break; else SWAPINT(i, j);
  }
  isortincr(f, i-1); isortincr(i, l);
}


/* ======================================================================
			       psortdecr
   ====================================================================== */

/* A specialized routine for sorting extreme points according to decreasing */
/* y-coordinate (decreasing x-coordinate in case of ties) */

void psortdecr(point *f, point *l)
{
  register point mi;
  register point *i, *j, *m;
  register int d, r;

  d = l - f + 1; 
  if (d <= 1) return;
  m = f + d / 2; if (DF(*f,*m)<0) SWAPP(f,m); 
  if (d == 2) return;
  if (DF(*m,*l)<0) { SWAPP(m,l); if (DF(*f,*m)<0) SWAPP(f,m); }
  if (d <= 3) return;
  mi = *m; i = f; j = l;
  for (;;) {
    do i++; while (DF(*i,mi) > 0);
    do j--; while (DF(*j,mi) < 0);
    if (i > j) break; else SWAPP(i, j);
  }
  psortdecr(f, i-1); psortdecr(i, l);
}


/* **********************************************************************
   **********************************************************************
			      Lower Bounds
   **********************************************************************
   ********************************************************************** */

/* ======================================================================
			      bound_zero
   ====================================================================== */

/* The continuous bound L_0 */

int bound_zero(allinfo *a, box *f, box *l)
{
  box *i, *m;
  stype vsum, lb;

  vsum = 0; 
  for (i = f, m = l+1; i != m; i++) vsum += i->vol;
  lb = (stype) ceil(vsum / (double) a->BVOL);
  return lb;
}


/* ======================================================================
                               rotate_solution
   ====================================================================== */

/* rotates the solution. After 3 rotations we return to original problem */

void rotate_solution(allinfo *a, box *f, box *l)
{
  register box *i, *m;
  register itype w, x;

  for (i = f, m = l+1; i != m; i++) {
    w = i->w; i->w = i->h; i->h = i->d; i->d = w;
    x = i->x; i->x = i->y; i->y = i->z; i->z = x;
  }
}


/* ======================================================================
			       rotate_problem
   ====================================================================== */

/* rotates the dimensions by one step */

void rotate_problem(allinfo *a, box *f, box *l)
{
  register box *i, *m;
  register itype w, x;

  for (i = f, m = l+1; i != m; i++) {
    w = i->w; i->w = i->h; i->h = i->d; i->d = w;
    x = i->x; i->x = i->y; i->y = i->z; i->z = x;
  }
  w = a->W; a->W = a->H; a->H = a->D; a->D = w;
}


/* ======================================================================
			       choose_boxes
   ====================================================================== */

/* returns a set of boxes with w > W2 and d > D2. This set is used in */
/* bound_one */

void choose_boxes(allinfo *a, box *f, box *l, int W2, int D2, 
		  box *fbox , box **lbox)
{
  box *i, *k, *m;

  for (i = f, m = l+1, k = fbox; i != m; i++) {
    if ((i->w > W2) && (i->d > D2)) { *k = *i; k++; }
  }
  *lbox = k-1;
}


/* ======================================================================
			       find_plist
   ====================================================================== */

/* returns a zero-terimanted list of distinct dimensions */

void find_plist(box *fbox, box *lbox, itype M, int dim, int *pl)
{
  register box *i, *m;
  register int *k, *j, *l;

  i = fbox; m = lbox+1; k = pl;
  switch (dim) {
    case WDIM: for (; i != m; i++) {
		 if (i->w <= M) { *k = i->w; k++; } 
	       } break;
    case HDIM: for (; i != m; i++) {
		 if (i->h <= M) { *k = i->h; k++; } 
	       } break;
    case DDIM: for (; i != m; i++) {
		 if (i->d <= M) { *k = i->d; k++; } 
	       } break;
  }
  if (k == pl) { *k = 0; return; }
  isortincr(pl, k-1);  /* sort the dimensions */
  for (j = pl+1, l = pl; j != k; j++) { /* remove duplicates */
    if (*j != *l) { l++; *l = *j; } 
  }
  l++; *l = 0;
}


/* ======================================================================
			       bound_one
   ====================================================================== */

/* Derive bound L_1 for a fixed dimension */

int bound_one_x(allinfo *a, box *f, box *l)
{
  register box *i, *m;
  register itype H, H2, h;
  register int p, j1, j2, j3, j2h, j2hp, j3h;
  int *pp, lb, lb_one, alpha, beta;
  box fbox[MAXBOXES], *lbox;
  int plist[MAXBOXES];

  if (l == f-1) return 0;
  lb = 1; H = a->H; H2 = H/2;
  choose_boxes(a, f, l, a->W/2, a->D/2, fbox, &lbox);
  if (lbox == fbox-1) { /* empty */ return lb; }

  find_plist(fbox, lbox, H2, HDIM, plist);
  for (pp = plist; *pp != 0; pp++) {
    p = *pp; j1 = j2 = j3 = j2h = j2hp = j3h = 0;
    for (i = fbox, m = lbox+1; i != m; i++) {
      h = i->h; 
      if (h > H-p) j1++;
      if ((H-p >= h) && (h > H2)) { j2++; j2h += h; j2hp += (H-h)/p; }
      if ((H2 >= h) && (h >= p)) { j3++; j3h += h; }
    }
    alpha = (int) ceil((j3h - (j2 * H - j2h)) / (double) H);
    beta  = (int) ceil((j3 - j2hp) / (double) (H/p));
    if (alpha < 0) alpha = 0;
    if (beta  < 0) beta  = 0;
    lb_one = j1 + j2 + MAXIMUM(alpha, beta);
    if (lb_one > lb) lb = lb_one;
  }
  return lb;
}


/* Derive bound L_1 as the best of all L_1 bounds for three rotations */

int bound_one(allinfo *a, box *f, box *l)
{
  int i, lb, lbx;

  lb = 0;
  for (i = WDIM; i <= DDIM; i++) {
    lbx = bound_one_x(a, f, l);
    if (lbx > lb) lb = lbx; 
    rotate_problem(a, f, l);
  } 
  return lb;
}


/* ======================================================================
			       bound_two
   ====================================================================== */

/* Derive bound L_2 for a fixed dimension */

int bound_two_x(allinfo *a, box *f, box *l)
{
  register box *i, *m;
  register itype W, H, D, w, h, d, W2, D2;
  register int p, q, k1h, k23v;
  int hlb1, lb, lb1, lbx, fract;
  int plist[MAXBOXES], qlist[MAXBOXES];
  int *qq, *pp;
  double WD, BVOL;

  /* derive bound_one */
  lb = lb1 = bound_one_x(a, f, l);
  W = a->W; H = a->H; D = a->D; hlb1 = H * lb1; 
  W2 = W/2; D2 = D/2; WD = W*(double)D; BVOL = a->BVOL;

  /* run through all values of p, q */
  find_plist(f, l, W2, WDIM, plist);
  find_plist(f, l, D2, DDIM, qlist);
  for (pp = plist; *pp != 0; pp++) {
    p = *pp;
    for (qq = qlist; *qq != 0; qq++) {
      q = *qq;
      k1h = k23v = 0;
      for (i = f, m = l+1; i != m; i++) {
	w = i->w; h = i->h; d = i->d;
	if ((w > W - p) && (d > D - q)) { k1h += h; continue; }
	if ((w >= p) && (d >= q)) { k23v += i->vol; }
      }
      fract = (int) ceil((k23v - (hlb1 - k1h)*WD) / BVOL);
      if (fract < 0) fract = 0;
      lbx = lb1 + fract;
      if (lbx > lb) lb = lbx;
    }
  }
  return lb;
}


/* Derive bound L_2 as the best of all L_2 bounds for three rotations */

int bound_two(allinfo *a, box *f, box *l)
{
  int i, lb, lbx;

  lb = 0;
  for (i = WDIM; i <= DDIM; i++) {
    lbx = bound_two_x(a, f, l);
    if (lbx > lb) lb = lbx;
    rotate_problem(a, f, l);
  } 
  return lb;
}


/* **********************************************************************
   **********************************************************************
			    heuristic filling
   **********************************************************************
   ********************************************************************** */

/* ======================================================================
			      onelayer
   ====================================================================== */

/* Fill a layer of depth f->d by arranging the boxes in a number of */
/* vertical shelfs. The boxes $i$ packed are assigned coordinates */
/* (i->x, i->y) and the field i->k is set to the argument d (layer no). */

void onelayer(allinfo *a, box *f, box *m, box *l, int d)
{
  int s, t;
  itype r; /* remaining width */
  itype width[MAXBOXES], height[MAXBOXES], x[MAXBOXES];
  box *i;
  
  qsort(f, DIF(f,m), sizeof(box), (funcptr) hcomp);
  r = a->W;
  x[0] = 0; width[0] = 0; height[0] = 0;
  for (s = 1, i = f; i != l+1; s++) {
    x[s] = x[s-1] + width[s-1];
    height[s] = 0;
    width[s] = i->w; if (width[s] > r) width[s] = r;
    r -= width[s];
    for ( ; i != l+1; i++) {
      for (t = s; t != 0; t--) {
	if (i->w <= width[t]) {
	  if (height[t] + i->h <= a->H) {
	    i->y = height[t]; i->x = x[t]; i->k = d;
	    height[t] += i->h; break;
	  }
	}
      }
      if ((t == 0) && (r > 0)) break; /* new strip */
    }
  }
}


/* ======================================================================
				  countarea
   ====================================================================== */

/* Select a subset of the boxes such that the selected boxes have a total */
/* area of two times the face of a bin (the parameter: barea) */

box *countarea(box *f, box *l, stype barea)
{
  box *i;
  stype area, d;

  for (area = 0, i = f; i != l+1; i++) {
    d = i->h * (ptype) i->w;
    area += d;
    if (area > 2*barea) return i-1;
  }
  return l;
}


/* ======================================================================
				  remboxes
   ====================================================================== */

/* Remove the boxes which were chosen for a layer, i.e., where i->k != 0. */
/* The depth of the layer is set equal to the deepest box chosen. */

box *remboxes(box *f, box *l, itype *depth)
{
  box *i, *j;
  itype d;

  for (i = f, j = l, d = 0; i != j+1; ) {
    if (i->k) { if (i->d > d) d = i->d; i++; } else { SWAP(i,j); j--; }
  }
  *depth = d;
  return i;
}


/* ======================================================================
				  assignboxes
   ====================================================================== */

/* Assign z-coordinates to the boxes, once they layers have been combined */
/* to individual bins by solving a 1-dimensional Bin-packing Problem. */

void assignboxes(heurpair *t, heurpair *u, ntype maxbin, box *f, box *l)
{
  box *i, *m;
  heurpair *h;
  itype b, z;

  /* derive z-coordinates for each layer */
  for (b = 1; b <= maxbin; b++) {
    z = 0;
    for (h = t; h <= u; h++) if (h->bno == b) { h->z = z; z += h->d; }
  }

  for (i = f, m = l+1; i != m; i++) {
    h = t + i->k - 1;
    i->z = h->z; i->bno = h->bno;
  }
}


/* ======================================================================
				 onedim_binpack
   ====================================================================== */

/* One-dimensional bin-packing algorithm. In each iteration, the next */
/* box is assigned to every open bin as well as to a new bin. The  */
/* algorithm terminates when MAXBPP iterations have been performed, */
/* returning the heuristic solution found. */

void onedim_binpack(heurpair *i, heurpair *f, heurpair *l, 
		    int *b, int bno, itype *z)
{
  int j, *bc;
  heurpair *k;

  bpiterat++; if (bpiterat > MAXBPP) return;
  if (bno >= *z) return; /* no hope of improvement */

  if (i > l) {
    *z = bno; 
    for (k = f; k <= l; k++) k->bno = k->b;
  } else {
    for (j = 0; j < bno; j++) {
      bc = b + j;
      if (i->d <= *bc) {
	*bc -= i->d; i->b = j+1;
	onedim_binpack(i+1, f, l, b, bno, z);
	*bc += i->d;
      }
    }
    bc = b + bno;
    *bc -= i->d; i->b = bno+1;
    onedim_binpack(i+1, f, l, b, bno+1, z);
    *bc += i->d;
  }
}


/* ======================================================================
			      dfirst_heuristic
   ====================================================================== */

/* Heuristic algorithm for the 3D BPP. A number of layers are constructed */
/* using the shelf approach to pack every layer. Then the individual layers */
/* are combined to bins by solving a 1D BPP defined in the layer depths. */

void dfirst_heuristic(allinfo *a)
{
  box *j, *f, *l, *m;
  int i, n, h, b[MAXBOXES];
  heurpair t[MAXBOXES];
  itype d, z;

  /* initialize boxes */
  for (j = a->fbox, m = a->lbox+1; j != m; j++) {
    j->bno = j->x = j->y = j->z = 0; j->k = FALSE;
  }

  /* fill layer one by one */
  for (f = a->fbox, l = a->lbox, h = 0; ; h++) {
    n = DIF(f,l); if (n == 0) break;
    qsort(f, n, sizeof(box), (funcptr) dcomp);
    m = countarea(f, l, a->W * (ptype) a->H);
    onelayer(a, f, m, l, h+1);
    f = remboxes(f, l, &d);
    t[h].d = d; t[h].bno = h+1;  /* initially put layers into separate bins */
    t[h].z = 0; t[h].lno = h+1;  /* this ensures fes. solution if terminate */
  }

  /* split into bins by solving 1-dim binpacking */
  for (i = 0; i < h; i++) b[i] = a->D;  /* all bins are empty */
  qsort(t, h, sizeof(heurpair), (funcptr) xcomp);
  z = h+1; bpiterat = 0;
  onedim_binpack(t, t, t+h-1, b, 0, &z); 
  qsort(t, h, sizeof(heurpair), (funcptr) lcomp); /* order according to lno */

  /* now assign bin number to each boxes */
  assignboxes(t, t+h-1, z, a->fbox, a->lbox);
  if (z < a->zlayer) a->zlayer = z;
  if (a->zlayer < a->z) savesol(a, a->fbox, a->lbox, a->zlayer);
}


/* ======================================================================
				dfirst3_heuristic
   ====================================================================== */

/* Call the heuristic dfirst_heuristic, for three different rotations */
/* of the problem */

void dfirst3_heuristic(allinfo *a)
{
  int i;
  double t1, t2;
 
  timer(&t1); 
  a->zlayer = a->n;  /* very bad incumbent solution */
  for (i = WDIM; i <= DDIM; i++) {
    dfirst_heuristic(a);
    rotate_solution(a, a->fopt, a->lopt);
    rotate_problem(a, a->fbox, a->lbox);
  }
  timer(&t2); 
  a->lhtime = t2 - t1;
}


/* **********************************************************************
   **********************************************************************
                    fill one 3D bin using GENERAL packing
   **********************************************************************
   ********************************************************************** */


/* ======================================================================
  			         modifyandpush
   ====================================================================== */

/* Push the relation "rel" between box i and box j to a stack. If "dom"
 * is true, the relation is removed from the domain. If "dom" is false,
 * the relation "rel" is imposed between boxes "i" and "j".
 */

void modifyandpush(int i, int j, int rel, boolean dom)
{
  dompos->i = i;
  dompos->j = j;
  dompos->domain = dom;
  if (dom) { 
    dompos->relation = rel;
    domain[i][j][rel] = FALSE; 
  } else {
    dompos->relation = relation[i][j];
    relation[i][j] = rel; 
  }
  dompos++; if (dompos == domend) error("stack filled\n");
}


/* ======================================================================
  			         popdomains
   ====================================================================== */

/* Pop all relations between boxes from the stack. The stack is emptied
 * downto the depth given by "pos".
 */

void popdomains(domainpair *pos)
{
  for (; dompos != pos; ) {
    dompos--;
    if (dompos->domain) {
      domain[dompos->i][dompos->j][dompos->relation] = TRUE;
    } else {
      relation[dompos->i][dompos->j] = dompos->relation;
    }
  }
}


/* ======================================================================
  			         findcoordinates
   ====================================================================== */

/* Find coordinates of boxes according to the currently pending relations.
 * In principle this can be done by topologically sorting the boxes according
 * to e.g. the left-right relations, and then assigning coordinates from
 * the left-most box to the right-most box.
 *   The following implementation is a simplified version, which runs through
 * all pairs of boxes, and checks whether they satisfy the relation, otherwise
 * moving one of the boxes right, up or behind, according to the given
 * relation. The process is repeated until no pairs of boxes violate a
 * relation. Computational experiments have shown that the present approach
 * for the considered instances is faster than a topological sorting followed
 * by a critical path calculation.
 *   If a box during the process gets moved outsides of the bin, then
 * the algorithm terminates with FALSE. Otherwise TRUE is returned, saying
 * that a feasible packing exists which respects the current relations.
 */

boolean findcoordinates(allinfo *a, int n, box *f)
{
  register box *g, *h;
  register int sum;
  int i, j, k, W, H, D;
  boolean changed;
  char *dom, *relij;
  domset *domij;

  /* check if feasible, i.e., at least one choice for each relation */
  W = a->W; H = a->H; D = a->D; 
  for (i = 0; i < n; i++) {
    j = i+1;
    relij = &(relation[i][j]); 
    domij = &(domain[i][j]); 
    for ( ; j < n; j++, relij++, domij++) {
      if (*relij != UNDEF) continue;
      dom = *domij; if (*dom) continue; 
      dom++;        if (*dom) continue;
      dom++;        if (*dom) continue;
      dom++;        if (*dom) continue;
      dom++;        if (*dom) continue;
      dom++;        if (*dom) continue;
      return FALSE;
    }
  }

  /* initialize coordinates */
  for (i = 0; i < n; i++) { g = f+i; g->x = g->y = g->z = 0; } 

  /* now determine the coordinates */
  a->exacttopo++;
  for (k = 0; k < n; k++) {
    a->exacttopn++;
    changed = FALSE; 
    for (i = 0; i < n; i++) {
      g = f+i; j = i+1; relij = &(relation[i][j]);
      for ( ; j < n; j++, relij++) {
        h = f+j;
        switch (*relij) {
          case UNDEF :
            /* do nothing */
            break;
          case LEFT  : 
            sum = g->x + g->w;
            if (h->x < sum) {
              h->x = sum; changed = TRUE; if (sum + h->w > W) return FALSE;
            }
            break;
          case RIGHT : 
            sum = h->x + h->w;
            if (g->x < sum) {
              g->x = sum; changed = TRUE; if (sum + g->w > W) return FALSE;
            }
            break;
          case UNDER : 
            sum = g->y + g->h;
            if (h->y < sum) {
              h->y = sum; changed = TRUE; if (sum + h->h > H) return FALSE;
            }
            break;
          case ABOVE : 
            sum = h->y + h->h;
            if (g->y < sum) {
              g->y = sum; changed = TRUE; if (sum + g->h > H) return FALSE;
            }
            break;
          case FRONT : 
            sum = g->z + g->d;
            if (h->z < sum) {
              h->z = sum; changed = TRUE; if (sum + h->d > D) return FALSE;
            }
            break;
          case BEHIND: 
            sum = h->z + h->d;
            if (g->z < sum) {
              g->z = sum; changed = TRUE; if (sum + g->d > D) return FALSE;
            }
            break;
        }
      }
    }
    if (!changed) { return TRUE; }
  }
  /* there must be a loop in the graph */
  return FALSE;
}


/* ======================================================================
  			         checkdomain
   ====================================================================== */

/* Temporarily impose the relation "value" between boxes "i" and "j",
 * and check whether a feasible assignment of coordinates exists which
 * respects all currently imposed relations. 
 *   If the relation cannot be satisfied, it is removed from the domain
 * and pushed to a stack, so that it can be restored upon backtracking.
 */

void checkdomain(allinfo *a, int i, int j, int n, box *f, int value)
{
  if (domain[i][j][value] == FALSE) return; /* not allowed in any case */
  relation[i][j] = value;
  if (findcoordinates(a, n, f) == FALSE) {
    modifyandpush(i, j, value, TRUE);
  } 
}


/* ======================================================================
  			         reducedomain
   ====================================================================== */

/* Constraint propagation algorithm. For each relation in the domain of
 * boxes "i" and "j", check if the relation has the posibility of being
 * satisfied. If some of the relations cannot be satisfied any more, they
 * are removed from the domain (and pushed to a stack, so that they can
 * be restored when the master search algorithm backtracks). If only one
 * relation remains in the domain, the relation is imposed at this node
 * and all descendant nodes.
 */

boolean reducedomain(allinfo *a, int n, box *f)
{
  register int i, j, k, l, m;

  m = 0;
  for (i = 0; i < n-1; i++) {
    for (j = i+1; j < n-1; j++) {
      if (relation[i][j] == UNDEF) {
        checkdomain(a, i, j, n, f, LEFT);
        checkdomain(a, i, j, n, f, RIGHT);
        checkdomain(a, i, j, n, f, UNDER);
        checkdomain(a, i, j, n, f, ABOVE);
        checkdomain(a, i, j, n, f, FRONT);
        checkdomain(a, i, j, n, f, BEHIND);
        relation[i][j] = UNDEF;
        for (k = LEFT, l = 0; k < UNDEF; k++) {
          if (domain[i][j][k]) { l++; m = k; }
        }
        if (l == 0) return FALSE;
        if (l == 1) { modifyandpush(i, j, m, FALSE); }
      }
    } 
  }
  return TRUE;
}


/* ======================================================================
  			         recpack
   ====================================================================== */

/* Recursive algorithm based on constraint programming used for assigning
 * relative positions to each pair of boxes. Each pair of boxes initially 
 * has an associated relation with domain LEFT, RIGHT, UNDER, ABOVE, FRONT, 
 * BEHIND. In each iteration of the algorithm a pair of boxes "i" and "j"
 * is assigned the relation "rel". Constraint propagation is then used to 
 * decrease the domains of remaining relations. 
 *   If it is not possible to assign coordinates to the boxes such that the 
 * currently imposed relations between pairs of boxes are respected, we 
 * backtrack.
 *   If each pair of boxes has been assigned a relation, and it is possible
 * to assign coordinates to the boxes such that the currently imposed 
 * relations between pairs of boxes are respected, we save the solution 
 * and return.
 *   Otherwise, constraint propagation is used to decrease the domains
 * of relations corresponding to each pairs of boxes. If a domain only
 * contains a single relation, the relation is fixed.
 *   The recursive step selects the next pair of boxes following "i" and "j"
 * and repeatedly assigns each relation from the domain to the relation 
 * variable.
 */

void recpack(allinfo *a, int i, int j, int n, box *f, int rel)
{
  int i1, j1;
  domainpair *pos;
  boolean feas;

  if (stopped) return;
  a->iter3d++;
  if ((a->iter3d == a->maxiter) && (a->maxiter != 0)) terminate = TRUE;
  a->subiterat++; 
  if (a->subiterat == IUNIT) { 
    a->subiterat = 0;
    a->iterat++; check_iterlimit(a->iterat, a->iterlimit);
    check_timelimit(a->timelimit);
  }
  if (terminate) return;

  relation[i][j] = rel;

  for (i1 = 0, j1 = 0; i1 != i && j1 != j; ) {
    i1++; if (i1 >= j1) { i1 = 0; j1++; }
    if (relation[i1][j1] == UNDEF) error("relation error %d %d\n", i1, j1);
  }  

  feas = findcoordinates(a, n, f); 
  if (!feas) return;

  if ((i == n-2) && (j == n-1)) { 
    feasible = TRUE;
    terminate = TRUE;
    memcpy(a->fsol, f, sizeof(box) * n); 
    return;
  }

  pos = dompos;
  feas = reducedomain(a, n, f);
  if (feas) {
    i++; if (i >= j) { i = 0; j++; }
    bblevel++;
    rel = relation[i][j];
    if (domain[i][j][LEFT ]) recpack(a, i, j, n, f, LEFT);
    if (domain[i][j][RIGHT]) recpack(a, i, j, n, f, RIGHT);
    if (domain[i][j][UNDER]) recpack(a, i, j, n, f, UNDER);
    if (domain[i][j][ABOVE]) recpack(a, i, j, n, f, ABOVE);
    if (domain[i][j][FRONT]) recpack(a, i, j, n, f, FRONT);
    if (domain[i][j][BEHIND])recpack(a, i, j, n, f, BEHIND);
    relation[i][j] = rel;
    bblevel--;
  }
  popdomains(pos);
}


/* ======================================================================
				 general_pack
   ====================================================================== */

/* General packing procedure, which tests whether boxes f..l can be packed
 * into a single bin. The algorithm is based on constraint programming, where
 * each pair of boxes initially has an associated relation with domain LEFT, 
 * RIGHT, UNDER, ABOVE, FRONT, BEHIND. Then the recursive algorithm "recpack" 
 * is called, which repeatedly tries to assign the relation a value, using
 * constraint propagation to decrease the domains of remaining boxes.
 */

boolean general_pack(allinfo *a, box *f, box *l)
{
  register int i, j, k, n;

  dompos = domstack;
  domend = domstack + STACKDEPTH;
  feasible = FALSE;
  terminate = FALSE;
  bblevel = 1;
  n = l-f+1;
  if (n > a->exactn) a->exactn = n;

  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      relation[i][j] = UNDEF;
      for (k = LEFT; k < UNDEF; k++) {
        domain[i][j][k] = TRUE;
      }
    }
  }
  domain[0][1][RIGHT ] = FALSE;
  domain[0][1][ABOVE ] = FALSE;
  domain[0][1][BEHIND] = FALSE;

  recpack(a, 0, 0, n, f, UNDEF); 
  return feasible;
}


/* ======================================================================
                                onebin_general
   ====================================================================== */

/* Check if boxes f..l can be packed into a single bin using general 
 * packing. If "fast" is TRUE, the problem is only solved heuristically,
 * hence if the algorithm returns FALSE we cannot rule out the posibility
 * of packing all boxes into the bin.
 */

boolean onebin_general(allinfo *a, box *f, box *l, boolean fast)
{
  boolean solution;
  double t1, t2;

  /* check time limit */
  if (stopped) return FALSE;

  a->iter3d = 0;
  a->maxiter = (fast ? MAXITER : 0); /* limited or infinitly many */
  a->exactcall++;

  /* calling general pack */
  timer(&t1);
  solution = general_pack(a, f, l);
  if (solution) checksol(a, f, l);
  timer(&t2);
  a->genertime += t2 - t1;
  return solution;
}


/* ======================================================================
				envelope
   ====================================================================== */

/* Find the two-dimensional envelope of the boxes given by extreme */
/* points f to l. */

void envelope(point *f, point *l, point *s1, point **sm,
	     itype W, itype H, itype D, itype RW, itype RH, itype cz, 
             point **ll, int *nz, stype *area)
{
  register point *i, *s, *t;
  register itype x, xx, y, z, ix, iy, iz, mz;
  register stype sum;

  /* find corner points and area */
  x = xx = z = 0; y = H; sum = 0; mz = D;
  for (i = t = f, s = s1; i != l; i++) {
    iz = i->z; if (iz <= cz) continue;
    if (iz < mz) mz = iz; /* find minimum next z coordinate */
    ix = i->x; if (ix <= x) {
      if (iz > z) { *t = *i; t++; } 
      continue;
    }
    iy = i->y;
    if ((x <= RW) && (iy <= RH)) { 
      s->x = x; s->y = iy; s->z = cz; s++; 
      sum += (x - xx) * (ptype) y; 
      y = iy; xx = x;
    }
    x = ix; z = iz; *t = *i; t++;
  }
  if (y != 0) sum += (W - xx) * (ptype) y;
  *sm = s-1;
  *area = sum;
  *nz = mz;
  *ll = t-1;
}

/* ======================================================================
			     checkdom
   ====================================================================== */

/* The 3D envelope is found by deriving a number of 2D envelopes. This */
/* may however introduce some "false" corner points, which are marked */
/* by the following algorithm. */

void checkdom(point *s1, point *sl, point *sm)
{
  register point *s, *t, *u;

  if (sl == s1-1) return;
  for (s = s1, t = sl+1, u = sm+1; t != u; t++) {
    while (s->x < t->x) { s++; if (s > sl) return; }
    if ((s->x == t->x) && (s->y == t->y)) t->z = 0;
  } 
}


/* ======================================================================
			     removedom
   ====================================================================== */

/* Remove "false" corner points marked by algorithm "checkdom". */

point *removedom(point *s1, point *sl)
{
  register point *i, *m, *k;
 
  for (i = k = s1, m = sl+1; i != m; i++) {
    if (i->z == 0) continue; 
    *k = *i; k++; 
  }
  return k-1;
}

/* ======================================================================
			     initboxes
   ====================================================================== */

/* Initialize boxes. Already placed boxes define extreme points, and thus */
/* they are placed into the list fc,..,lc. Not placed boxes are used to */
/* derive minimum dimensions. */

void initboxes(box *f, box *l, point *fc, point **lc, 
               int *minw, int *minh, int *mind)
{
  register box *j, *m;
  register point *k;
  register int minx, miny, minz;

  minx = *minw; miny = *minh; minz = *mind; 
  for (j = f, k = fc, m = l+1; j != m; j++) {
    if (j->k) { /* defines an extreme box */
      k->x = j->x+j->w; k->y = j->y+j->h; k->z = j->z+j->d; k++;
    } else { /* free box */
      if (j->w < minx) minx = j->w;
      if (j->h < miny) miny = j->h;
      if (j->d < minz) minz = j->d;
    }
  }
  *minw = minx; *minh = miny; *mind = minz; 
  *lc = k-1;
}


/* ======================================================================
			      findplaces
   ====================================================================== */

/* Find all corner points, where a new box may be placed as well as the */
/* volume of the "envelope" occupied by already placed boxes. Already */
/* placed boxes are given by f,..,l, while a list of possible placings */
/* is returned in s1,..,sm. The return value of the procedure is an upper */
/* bound on the possible filling of this bin. */

stype findplaces(allinfo *a, box *f, box *l, 
                 point *s1, point **sm, stype fill)
{
  register point *k;
  int minw, minh, mind, W, H, D, RW, RH, z, zn;
  point *sk, *lc, *sl, *st, *s0;
  stype vol, area;
  point fc[MAXBOXES+1];

  /* select boxes which are chosen, and find min dimensions of unchosen */
  minw = W = a->W; minh = H = a->H; mind = D = a->D; 
  initboxes(f, l, fc, &lc, &minw, &minh, &mind);

  /* sort the boxes according to max y (first) max x (second) */
  if (lc >= fc) psortdecr(fc, lc); /* order decreasing */

  /* for each z-coordinate find the 2D envelope */
  vol = 0; sl = s1-1; sk = s1; s0 = NULL;
  RW = W - minw; RH = H - minh; 
  lc++; k = lc; k->x = W+1; k->y = 0; k->z = a->D+1;
  for (z = 0; z != D; z = zn) {
    /* find 2D envelope for all boxes which cover *z */
    envelope(fc, lc+1, sl+1, &st, W, H, D, RW, RH, z, &lc, &zn, &area);
    if (zn + mind > D) zn = D; /* nothing fits between zn and D */
    vol += area * (ptype) (zn - z); /* update volume */
    checkdom(sk, sl, st); /* check for dominance */
    sk = sl+1; sl = st; 
    if (z == 0) s0 = sl;
  }
  *sm = removedom(s0+1, sl);
  return fill + (a->BVOL - vol); /* bound is curr filling + all free vol */
}


/* ======================================================================
				branch
   ====================================================================== */

/* Recursive algorithm for solving a knapsack filling of a single bin. */
/* In each iteration, the set of feasible positions for placing a new */
/* box is found, and an upper bound on the filling is derived. If the */
/* bound indicates that an improved solution still may be obtained, every */
/* box is tried to be placed at every feasible position, before calling */
/* the algorithm recursively. */

void branch(allinfo *a, box *f, box *l, int miss, stype fill)
{
  register box *i;
  register point *s;
  int d;
  stype bound;
  point *sl, s1[9*MAXBOXES];

  if (stopped) return;
  a->iter3d++;
  if ((a->iter3d == a->maxiter) && (a->maxiter != 0)) terminate = TRUE;
  if (a->iter3d % 1000 == 0) check_timelimit(a->timelimit);
  a->subiterat++; 
  if (a->subiterat == IUNIT) { 
    a->subiterat = 0;
    a->iterat++; check_iterlimit(a->iterat, a->iterlimit);
  }
  if (terminate) return;

  /* find min/max dimensions of remaining boxes */
  if (miss == 0) {
    /* none left -> good: save solution */
    memcpy(a->fsol, f, sizeof(box) * DIF(f,l));
    a->maxfill = a->BVOL; terminate = TRUE; a->miss = miss;
  } else {
    /* check if better filling */
    if (fill > a->maxfill) {
      memcpy(a->fsol, f, sizeof(box) * DIF(f,l)); 
      a->maxfill = fill; a->miss = miss;
    }

    /* find bound and positions to place new boxes */
    bound = findplaces(a, f, l, s1, &sl, fill);

    if (bound > a->maxfill) {
      /* for each position in S, try to place an box there */
      for (s = s1; s != sl+1; s++) {
	for (i = f, d = 0; i != l+1; i++) {
	  if (i->k) continue; /* already chosen */

	  /* see if box fits at position s */
	  if ((int) (s->x) + i->w > a->W) continue;
	  if ((int) (s->y) + i->h > a->H) continue;
	  if ((int) (s->z) + i->d > a->D) continue;

	  /* place box and call recursively */
	  i->k = TRUE; i->x = s->x; i->y = s->y; i->z = s->z;
	  branch(a, f, l, miss - 1, fill + i->vol);
	  i->k = FALSE; i->x = i->y = i->z = 0; d++;
	  if (d == a->mcut) break; /* terminate after mcut branches */
	  if (terminate) break;
	}
      }
    }
  }
}


/* ======================================================================
				mcut_heuristic
   ====================================================================== */

/* Knapsack filling of a single bin, solved heuristically. The heuristic */
/* is based on the exact algorithm for knapsack filling a single bin, where */
/* only a limited number of sub-nodes are considered at every branching node */
/* (the so-called m-cut approach) */
 
void mcut_heuristic(allinfo *a)
{
  box *f, *l, *i, *j, *m;
  int b, n;

  /* initialize boxes */
  for (i = a->fbox, m = a->lbox+1; i != m; i++) {
    i->bno = i->x = i->y = i->z = 0; i->k = FALSE;
  }

  /* fill bins one by one */
  f = a->fbox; l = a->lbox;
  for (b = 1; ; b++) {
    /* fill one bin */
    for (i = f; i <= l; i++) i->k = FALSE; /* box not chosen */
    a->iter3d = 0;
    a->maxfill = 0;
    a->miss = DIF(f,l);
    a->maxiter = 5*MAXITER;
    terminate = FALSE;
    n = DIF(f,l);
    a->mcut = 2;
    if (n < 15) a->mcut = 3;
    if (n < 10) a->mcut = 4;
    branch(a, f, l, n, 0);

    /* copy solution */
    for (i = a->fsol, j = f, m = l+1; j != m; i++, j++) *j = *i;

    /* remove chosen boxes */
    for (i = f; i <= l;) if (i->k) { i->bno = b; SWAP(i,l); l--; } else i++;

    /* check if finished */
    if (l == f-1) break;
  }
  if (b < a->zmcut) a->zmcut = b; /* save solution */
  if (a->zmcut < a->z) savesol(a, a->fbox, a->lbox, a->zmcut);
}


/* ======================================================================
				mcut3_heuristic
   ====================================================================== */

/* Knapsack filling of a single bin, solved heuristically. Three different */
/* rotations of the problem are considered, and the best found solution */
/* is selected. */

void mcut3_heuristic(allinfo *a)
{
  int i;
  double t1, t2;
 
  timer(&t1); 
  a->zmcut = a->n;  /* very bad lower bound */
  for (i = WDIM; i <= DDIM; i++) {
    mcut_heuristic(a);
    rotate_solution(a, a->fopt, a->lopt);
    rotate_problem(a, a->fbox, a->lbox);
  }
  timer(&t2);
  a->mhtime = t2 - t1;
}


/* **********************************************************************
   **********************************************************************
 	       branch-and-bound for 3D bin-packing problem
   **********************************************************************
   ********************************************************************** */


/* ======================================================================
				 fits
   ====================================================================== */

/* The routine "fitsm" checks whether a given subset of boxes fits into */
/* a single bin. To improve performance, specialized algorithms are derived */
/* for cases with two to three boxes */

boolean fits2(box *i, box *j, itype W, itype H, itype D)
{
  /* all coordinates are initialized to zero, so just adjust changes! */
  /* the 2-box solution is always guillotine cuttable */
  if (i->w + j->w <= W) { j->x = i->w; return TRUE; }
  if (i->h + j->h <= H) { j->y = i->h; return TRUE; }
  if (i->d + j->d <= D) { j->z = i->d; return TRUE; }
  return FALSE;
}


boolean fits2p(box *i, box *j, itype W, itype H, itype D)
{
  if (i->w + j->w <= W) return TRUE;
  if (i->h + j->h <= H) return TRUE;
  if (i->d + j->d <= D) return TRUE;
  return FALSE;
}


boolean fits3(box *i, box *j, box *k, itype W, itype H, itype D)
{
  box *t;
  itype w, h, d, r;

  /* all coordinates are initialized to zero, so just adjust changes! */
  /* the 3-box solution can either be cut by guillotine cuts */
  for (r = 1; r <= 3; r++) {
    /* cut (i,j) and (k) in one of three dimensions */
    w = W - k->w; h = H - k->h; d = D - k->d; 
    if ((i->w<=w) && (j->w<=w) && fits2(i,j,w,H,D)) { k->x = w; return TRUE; } 
    if ((i->h<=h) && (j->h<=h) && fits2(i,j,W,h,D)) { k->y = h; return TRUE; } 
    if ((i->d<=d) && (j->d<=d) && fits2(i,j,W,H,d)) { k->z = d; return TRUE; } 
    t = i; i = j; j = k; k = t;
  }


  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (wi,0,0); (xk,yk,zk) = (0,hi,dj) */
  if ((i->w+j->w <= W) && (i->h+k->h <= H) && (j->d+k->d <= D)) {
    j->x = i->w; k->y = i->h; k->z = j->d; return TRUE;
  } 
  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (wk,0,di); (xk,yk,zk) = (0,hi,0) */
  if ((j->w+k->w <= W) && (i->h+k->h <= H) && (i->d+j->d <= D)) {
    j->x = k->w; j->z = i->d; k->y = i->h; return TRUE;
  } 
  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (0,hi,dk); (xk,yk,zk) = (wi,0,0) */
  if ((i->w+k->w <= W) && (i->h+j->h <= H) && (k->d+j->d <= D)) {
    j->y = i->h; j->z = k->d; k->x = i->w; return TRUE;
  } 
  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (0,hi,0); (xk,yk,zk) = (wj,0,di) */
  if ((j->w+k->w <= W) && (i->h+j->h <= H) && (k->d+i->d <= D)) {
    j->y = i->h; k->x = j->w; k->z = i->d; return TRUE;
  } 
  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (wi,0,0); (xk,yk,zk) = (0,hj,di) */ 
  if ((i->w+j->w <= W) && (j->h+k->h <= H) && (i->d+k->d <= D)) { 
    j->x = i->w; k->y = j->h; k->z = i->d; return TRUE;
  } 
  /* (xi,yi,zi) = (0,0,0); (xj,yj,zj) = (0,0,di); (xk,yk,zk) = (wi,hj,0) */ 
  if ((i->w+k->w <= W) && (j->h+k->h <= H) && (i->d+j->d <= D)) { 
    j->z = i->d; k->x = i->w; k->y = j->h; return TRUE;
  } 
  return FALSE; 
}  


boolean fitsm(allinfo *a, box *t, box *k, boolean fast)
{
  boolean fits;
  ntype lb;

  lb = bound_two(a, t, k);
  if (lb > 1) return FALSE;
  a->exfill++; fits = FALSE;
  fits = onebin_general(a, t, k, fast); 
  return fits;
}


/* ======================================================================
				onebin_decision
   ====================================================================== */

/* The following procedure checks whether a new box "j" fits into the the */
/* bin "bno" (together with already placed boxes in the bin). If the answer */
/* is "no" then definitly it is not possible to place the box into the bin. */

boolean onebin_decision(allinfo *a, box *j, int bno)
{
  register box *i, *k, *m;
  box t[MAXBOXES];
  boolean fits;
  int size;

  for (i = a->fbox, m = j, k = t-1; i != m; i++) {
    if (i->bno == bno) { k++; *k = *i; k->x = k->y = k->z = 0; k->ref = i; }
  }
  k++; *k = *j; k->x = k->y = k->z = 0; k->ref = j; k->k = TRUE; 

  size = DIF(t,k); 
  switch (size) {
    case 0: error("no boxes in onebin_decision");
    case 1: fits = TRUE; k->x = k->y = k->z = 0; break;
    case 2: fits = fits2(t, k, a->W, a->H, a->D); break;
    case 3: fits = fits3(t, t+1, k, a->W, a->H, a->D); break;
    default: fits = fitsm(a, t, k, FALSE); break;
  }
  if (size <= 3) {
    a->subiterat++; 
    if (a->subiterat == IUNIT) { 
      a->subiterat = 0;
      a->iterat++; check_iterlimit(a->iterat, a->iterlimit);
    }
  }

  if (fits) {
    /* copy solution back */
    for (i = t, m = k+1; i != m; i++) {
      k = i->ref; k->x = i->x; k->y = i->y; k->z = i->z; k->k = TRUE;
    }
  }
  return fits;
}


/* ======================================================================
				onebin_heuristic
   ====================================================================== */

/* This is a heuristic version of "onebin_decision". If the answer is "yes" */
/* then a heuristic solution has been found where boxes f,..,l fit into a  */
/* bin. If the answer is "no" then a filling may still be possible, but it */
/* was not found by the heuristic. */ 

boolean onebin_heuristic(allinfo *a, box *f, box *l)
{
  box *i, *m;
  boolean fits;
 
  for (i = f, m = l+1; i != m; i++) { i->x = i->y = i->z = 0; }
  switch (DIF(f,l)) {
    case 0: error("no boxes in onebin_heuristic");
    case 1: fits = TRUE; break;
    case 2: fits = fits2(f, l, a->W, a->H, a->D); break;
    case 3: fits = fits3(f, f+1, l, a->W, a->H, a->D); break;
    default: fits = fitsm(a, f, l, TRUE); break;
  }
  return fits;
}


/* ======================================================================
				try_close
   ====================================================================== */

/* A bin may be closed if no more boxes fit into it. The present version */
/* uses a more advanced criterion: First, the set of boxes which fit into */
/* bin "bno" is derived. This is done, by testing whether each box (alone) */
/* fits together with the already placed boxes in the bin. Having derived */
/* the set of additional boxes that (individually) fits into the bin, it is */
/* tested whether a solution exists where all the additional boxes are */
/* placed in the bin. If this is the case, we have found a optimal placing */
/* of the additional boxes, and thus we may close the bin. */

boolean try_close(allinfo *a, box **curr, ntype bno,
                 box *oldf, box **oldl, box **oldlc, ntype *oldnoc, 
                 boolean *oldclosed, int level)
{
  register box *j, *m, *k, *r, *i, *s;
  register stype vol;
  box f[MAXBOXES];
  ntype h, n, b;
  boolean didclose, fits;

  if (level > MAXCLOSE) return FALSE;
  i = *curr; didclose = FALSE;
  for (b = 1; b <= bno; b++) {
    if (i > a->lbox) break;
    if (a->closed[b]) continue;
    for (j = a->fbox, m = i, k = f, n = 0, vol = 0; j != m; j++) {
      if (j->bno == b) { *k = *j; k->ref = j; k++; n++; vol += j->vol; }
    }
    if (n == 0) error("bin with no boxes");
    if (vol < a->BVOL/2) continue;
    for (j = i, h = 0, m = a->lbox+1; j != m; j++) {
      if ((j->no > a->n) || (j->no < 1)) error("bad no");
      fits = onebin_decision(a, j, b);
      if (fits) { *k = *j; k->ref = j; k++; h++; vol += j->vol; }
      if (vol > a->BVOL) break;
    }
    if (vol > a->BVOL) continue;
    if (onebin_heuristic(a, f, k-1)) {
      if (!didclose) { /* take backup of table when first bin closed */
        memcpy(oldclosed, a->closed, sizeof(boolean)*(bno+1));
        memcpy(oldf, a->fbox, sizeof(box)*DIF(a->fbox,a->lbox));
        *oldl = a->lbox; *oldlc = a->lclosed; *oldnoc = a->noc;
      }
      a->closed[b] = TRUE; s = a->lclosed; didclose = TRUE;
      a->noc++; if (a->noc > a->maxclose) a->maxclose = a->noc;
      for (j = f; j != k; j++) { 
        r = j->ref; r->bno = b; r->k = TRUE; 
        r->x = j->x; r->y = j->y; r->z = j->z; 
      }
      for (j = k = a->fbox, m = a->lbox+1; j != m; j++) {
        if (j->bno == b) { s++; *s = *j; } else { *k = *j; k++; } 
      }
      a->lbox = k-1; a->lclosed = s;
      i -= n; /* reposition current box */
    }
  }
  *curr = i;
  return didclose;
}


/* ======================================================================
                                free_close
   ====================================================================== */

/* Reopen a closed bin when backtracking. */

void free_close(allinfo *a, ntype bno, 
                box *oldf, box *oldl, box *oldlc, ntype oldnoc,
                boolean *oldclosed)
{
  a->lbox = oldl; a->lclosed = oldlc; a->noc = oldnoc;
  memcpy(a->fbox, oldf, sizeof(box)*DIF(a->fbox,oldl));
  memcpy(a->closed, oldclosed, sizeof(boolean)*(bno+1));
}


/* ======================================================================
				rec_binpack
   ====================================================================== */

/* Recursive algorithm for 3D Bin-packing Problem. In each iteration, the */
/* next box "i" is assigned to every open bin, as well as to a new bin. */

void rec_binpack(allinfo *a, box *i, int bno, ntype lb, int level)
{
  box of[MAXBOXES], *ol, *ox;
  boolean ocl[MAXBOXES];
  ntype b, oc;
  boolean more;

  if (bno >= a->z) return; /* used too many bins */
  if (a->z == a->lb) return; /* optimal solution found */
  a->subnodes++;
  if (a->subnodes == IUNIT) { a->subnodes = 0; a->nodes++; }
  check_nodelimit(a->nodes, a->nodelimit);
  check_iterlimit(a->iterat, a->iterlimit);
  check_timelimit(a->timelimit);
  if (stopped) return;

  if (i == a->lbox+1) {
    /* all boxes assigned, must be better solution */
    savesol(a, a->fbox, a->lbox, bno);
  } else {
    more = try_close(a, &i, bno, of, &ol, &ox, &oc, ocl, level);
    if (i == a->lbox+1) { /* all boxes went into closed bins */
      savesol(a, a->fbox, a->lbox, bno);
    } else {
      if (more) lb = a->noc + bound_two(a, a->fbox, a->lbox);
      if (lb < a->z) {
        for (b = 1; b <= bno; b++) {
          if (a->closed[b]) continue; /* cannot add to closed bin */
            if (onebin_decision(a, i, b)) {
  	    i->bno = b;
	    rec_binpack(a, i+1, bno, lb, level+1);
	    i->bno = 0;
  	  }
        }
        i->bno = bno+1; i->x = i->y = i->z = 0;
        a->closed[i->bno] = FALSE;
        rec_binpack(a, i+1, bno+1, lb, level+1);
        i->bno = 0;
      }
    }
    /* restore */
    if (more) free_close(a, bno, of, ol, ox, oc, ocl);
  }
}


/* **********************************************************************
   **********************************************************************
			     Main procedure
   **********************************************************************
   ********************************************************************** */

/* ======================================================================
				clearboxes
   ====================================================================== */

void clearboxes(allinfo *a)
{
  box *i, *m;

  for (i = a->fbox, m = a->lbox+1; i != m; i++) {
    i->x = i->y = i->z = i->bno = 0; i->k = FALSE; i->vol = VOL(i);
  }
  /* sort nonincreasing volume */
  qsort(a->fbox, (m-a->fbox), sizeof(box), (funcptr) vcomp);
}


/* ======================================================================
				copyboxes
   ====================================================================== */

void copyboxes(allinfo *a, int *w, int *h, int *d, int W, int H, int D)
{
  box *i, *m;
  int k;

  for (i = a->fbox, m = a->lbox+1, k = 0; i != m; i++, k++) {
    i->no = k+1; i->w = w[k]; i->h = h[k]; i->d = d[k];
    if ((w[k] < 1) || (w[k] > W)) error("bad w\n");
    if ((h[k] < 1) || (h[k] > H)) error("bad h\n");
    if ((d[k] < 1) || (d[k] > D)) error("bad d\n");
  }

  clearboxes(a);
}


/* ======================================================================
				returnboxes
   ====================================================================== */

void returnboxes(allinfo *a, int *x, int *y, int *z, int *bno)
{
  box *i, *m;
  int k;

  for (i = a->fopt, m = a->lopt+1; i != m; i++) {
    k = i->no-1; x[k] = i->x; y[k] = i->y; z[k] = i->z; bno[k] = i->bno;
  }
}


/* ======================================================================
				binpack3d
   ====================================================================== */

void binpack3d(int n, int W, int H, int D,
               int *w, int *h, int *d, 
               int *x, int *y, int *z, int *bno,
               int *lb, int *ub, 
               int nodelimit, int iterlimit, int timelimit, 
               int *nodeused, int *iterused, int *timeused)
{
  allinfo a;
  box t0[MAXBOXES], t1[MAXBOXES], t2[MAXBOXES], t3[MAXBOXES];
  boolean cl[MAXBOXES];
  
  /* start the timer */ 
  timer(NULL); stopped = FALSE; 
 
  /* copy info to a structure */
  if (n+1 > MAXBOXES) error("too big instance");
  a.n = n; a.W = W; a.H = H; a.D = D;
  a.fbox     = t0; 
  a.lbox     = a.fbox + a.n - 1; 
  a.fsol     = t1;
  a.lsol     = a.fsol + a.n - 1;
  a.fopt     = t2;
  a.lopt     = a.fopt + a.n - 1;
  a.fclosed  = t3;
  a.lclosed  = a.fclosed - 1;
  a.noc      = 0;
  a.closed   = cl;
  a.BVOL     = W * (ptype) H * D;
  a.maxfill  = 0;
  a.exfill   = 0;
  a.nodelimit= 0;
  a.iterlimit= 0;
  a.timelimit= 0;
  a.nodes    = 0;
  a.subnodes = 0;
  a.iterat   = 0;
  a.subiterat= 0;
  a.didpush  = 0;
  a.maxclose = 0;
  a.genertime= 0;
  a.robottime= 0;
  a.z        = a.n+1;

  /* copy boxes to internal structure */
  copyboxes(&a, w, h, d, W, H, D);

  /* find bounds */
  a.bound0 = bound_zero(&a, a.fbox, a.lbox);
  a.bound1 = bound_one(&a, a.fbox, a.lbox);
  a.bound2 = bound_two(&a, a.fbox, a.lbox);
  a.lb = a.bound2;

  /* find heuristic solution */
  dfirst3_heuristic(&a);

  /* initialize search limits for exact search */
  a.nodelimit= nodelimit;
  a.iterlimit= iterlimit;
  a.timelimit= timelimit;

  /* outer tree enummeration */
  clearboxes(&a); /* clear positions */
  rec_binpack(&a, a.fbox, 0, a.lb, 1);
  timer(&(a.time));

  /* check found solution */
  /* checksol(&a, a.fopt, a.lopt); */

  /* copy boxes back to arrays */
  returnboxes(&a, x, y, z, bno);
  *ub = a.z;
  *lb = (stopped ? a.lb : a.z);
  *nodeused = a.nodes;
  *iterused = a.iterat;
  *timeused = a.time * 1000;
}




================================================
FILE: pyshipping/__init__.py
================================================
"""pyShipping contains routines related to shipping and warehousing."""


================================================
FILE: pyshipping/addressvalidation.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
addressvalidation.py - check the validity of addresses

Should once integrate with
http://www.deutschepost.de/dpag?tab=1&skin=hi&check=yes&lang=de_DE&xmlFile=link1015574_1021
http://www.isogmbh.de/leistungen/dataquality-management/adressvalidierung.html
or http://opengeodb.hoppe-media.com/


Created by Maximillian Dornseif on 2009-09-03.
Copyright (c) 2009, 2010 HUDORA. All rights reserved.
"""

import unittest


def validate(adr, servicelevel=1):
    """Validates an address and returns a possibly corrected address.

    'adr' should be a object conforming to the address protocol
        - see http://cybernetics.hudora.biz/projects/wiki/AddressProtocol
    'servicelevel' can be an integer with the following values:
    1 - generic validation, no money/effort should be spend on correction and suggestions
    2 - TBD.

    returns (status, message, [corrected addresses and variants])

    status can be:
    '10invalid' - address is for sure non deliverable in this form
    '20troubled' - bounced before or is unlikely to be correct - possible alternatives are returned
    '30ok' - likely to work
    '31ok' - likely to work but was corrected
    '40verified' - we are sure it works
    """

    adr['land'] = adr['land'].strip()
    adr['plz'] = adr['plz'].strip()

    if adr['land'] != 'IE' and not adr['plz']:
        return ('10invalid', 'Postleitzahl fehlt', [adr])

    if adr['land'] == 'DE' and len(adr.get('plz', '')) != 5:
        return ('10invalid', 'Postleitzahl fehlerhaft', [adr])

    return ('30ok', '', [adr])


class AddressvalidationTests(unittest.TestCase):
    """Tests for the address validation facility."""

    def setUp(self):
        """Set up test address base."""
        self.address = {'name1': 'HUDORA GmbH',
                        'name2': 'Abt. Cybernetics',
                        'strasse': 'Jägerwald 13',
                        'land': 'DE',
                        'plz': '42897',
                        'ort': 'Remscheid',
                        'tel': '+49 2191 60912 0',
                        'fax': '+49 2191 60912 50',
                        'mobil': '+49 175 00000xx',
                        'email': 'nobody@hudora.de'}

    def test_good_address(self):
        """Test if correct addresses are considered correct."""
        self.assertEqual(validate(self.address)[0], '30ok')
        self.assertEqual(validate(self.address)[1], '')

    def test_missing_zip(self):
        """Test if correct addresses are considered correct."""
        self.address['plz'] = ''
        self.assertEqual(validate(self.address)[0], '10invalid')

    def test_short_zip(self):
        """Test if correct addresses are considered correct."""
        self.address['plz'] = '123'
        self.assertEqual(validate(self.address)[0], '10invalid')

    def test_long_zip(self):
        """Test if correct addresses are considered correct."""
        self.address['plz'] = '12345 Rade'
        self.assertEqual(validate(self.address)[0], '10invalid')


if __name__ == '__main__':
    unittest.main()


================================================
FILE: pyshipping/binpack.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
binpack.py

Created by Maximillian Dornseif on 2010-08-16.
Copyright (c) 2010 HUDORA. All rights reserved.
"""


import binpack_simple


def binpack(packages, bin=None, iterlimit=5000):
    return binpack_simple.binpack(packages, bin, iterlimit)


def test(func):
    import time
    from package import Package
    fd = open('testdata.txt')
    vorher = 0
    nachher = 0
    start = time.time()
    counter = 0
    for line in fd:
        counter += 1
        if counter > 450:
            break
        packages = [Package(pack) for pack in line.strip().split()]
        if not packages:
            continue
        bins, rest = func(packages)
        if rest:
            print "invalid data", rest, line
        else:
            vorher += len(packages)
            nachher += len(bins)
    print time.time() - start,
    print vorher, nachher, float(nachher) / vorher * 100


if __name__ == '__main__':
    print "py",
    test(binpack)


import time
from pyshipping.package import Package


================================================
FILE: pyshipping/binpack_simple.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
binpack_simple.py

This code implemnts 3D bin packing in pure Python

Bin packing in this context is calculating the best way to store a number of differently sized boxes in a
number of fixed sized "bins". It is what usually happens in a Warehouse bevore shipping.

The Algorithm has a simple fit first approach, but can archive relative good results because it tries
different rectangular rotations of the packages. Since the Algorithm can't interate over all possible
combinations we use a heuristic approach.

For a few dozen packages it reaches adaequate runtime. Below are the results calculated about a set of
500 real world packing problems.

Binsize     Runtime                 Recuction in shipped Packages
600x400x400 31.5993559361 4970 2033 40.9054325956
600x445x400 31.5596890450 4970 1854 37.3038229376
600x500x400 29.1432909966 4970 1685 33.9034205231


On the datasets we operate on we can archive comparable preformance to academic higly optimized C code
like David Pisinger's 3bpp:

     Runtime                 Recuction in shipped Packages
py   11.3468761444 2721 1066 39.1767732451
3bpp 9.95857691765 2721 1086 39.9117971334

The Python implementation is somewhat slower but can archive slightly better packing results on our
datasets.


Created by Maximillian Dornseif on 2010-08-14.
Copyright (c) 2010 HUDORA. All rights reserved.
"""


import time
import random


def packstrip(bin, p):
    """Creates a Strip which fits into bin.

    Returns the Packages to be used in the strip, the dimensions of the strip as a 3-tuple
    and a list of "left over" packages.
    """
    # This code is somewhat optimized and somewhat unreadable
    s = []                # strip
    r = []                # rest
    ss = sw = sl = 0      # stripsize
    bs = bin.heigth       # binsize
    sapp = s.append       # speedup
    rapp = r.append       # speedup
    ppop = p.pop          # speedup
    while p and (ss <= bs):
        n = ppop(0)
        nh, nw, nl = n.size
        if ss + nh <= bs:
            ss += nh
            sapp(n)
            if nw > sw:
                sw = nw
            if nl > sl:
                sl = nl
        else:
            rapp(n)
    return s, (ss, sw, sl), r + p


def packlayer(bin, packages):
    strips = []
    layersize = 0
    layerx = 0
    layery = 0
    binsize = bin.width
    while packages:
        strip, (sizex, stripsize, sizez), rest = packstrip(bin, packages)
        if layersize + stripsize <= binsize:
            packages = rest
            if not strip:
                # we were not able to pack anything
                break
            layersize += stripsize
            layerx = max([sizex, layerx])
            layery = max([sizez, layery])
            strips.extend(strip)
        else:
            # Next Layer please
            packages = strip + rest
            break
    return strips, (layerx, layersize, layery), packages


def packbin(bin, packages):
    packages.sort()
    layers = []
    contentheigth = 0
    contentx = 0
    contenty = 0
    binsize = bin.length
    while packages:
        layer, (sizex, sizey, layersize), rest = packlayer(bin, packages)
        if contentheigth + layersize <= binsize:
            packages = rest
            if not layer:
                # we were not able to pack anything
                break
            contentheigth += layersize
            contentx = max([contentx, sizex])
            contenty = max([contenty, sizey])
            layers.extend(layer)
        else:
            # Next Bin please
            packages = layer + rest
            break
    return layers, (contentx, contenty, contentheigth), packages


def packit(bin, originalpackages):
    packedbins = []
    packages = sorted(originalpackages)
    while packages:
        packagesinbin, (binx, biny, binz), rest = packbin(bin, packages)
        if not packagesinbin:
            # we were not able to pack anything
            break
        packedbins.append(packagesinbin)
        packages = rest
    # we now have a result, try to get a better result by rotating some bins

    return packedbins, rest


# In newer Python versions these van be imported:
# from itertools import permutations
def product(*args, **kwds):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    pools = map(tuple, args) * kwds.get('repeat', 1)
    result = [[]]
    for pool in pools:
        result = [x + [y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)


def permutations(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)


class Timeout(Exception):
    pass


def allpermutations_helper(permuted, todo, maxcounter, callback, bin, bestpack, counter):
    if not todo:
        return counter + callback(bin, permuted, bestpack)
    else:
        others = todo[1:]
        thispackage = todo[0]
        for dimensions in set(permutations((thispackage[0], thispackage[1], thispackage[2]))):
            thispackage = Package(dimensions, nosort=True)
            if thispackage in bin:
                counter = allpermutations_helper(permuted + [thispackage], others, maxcounter, callback,
                                                 bin, bestpack, counter)
            if counter > maxcounter:
                raise Timeout('more than %d iterations tries' % counter)
        return counter


def trypack(bin, packages, bestpack):
    bins, rest = packit(bin, packages)
    if len(bins) < bestpack['bincount']:
        bestpack['bincount'] = len(bins)
        bestpack['bins'] = bins
        bestpack['rest'] = rest
    if bestpack['bincount'] < 2:
        raise Timeout('optimal solution found')
    return len(packages)


def allpermutations(todo, bin, iterlimit=5000):
    random.seed(1)
    random.shuffle(todo)
    bestpack = dict(bincount=len(todo) + 1)
    try:
        # First try unpermuted
        trypack(bin, todo, bestpack)
        # now try permutations
        allpermutations_helper([], todo, iterlimit, trypack, bin, bestpack, 0)
    except Timeout:
        pass
    return bestpack['bins'], bestpack['rest']


def binpack(packages, bin=None, iterlimit=5000):
    """Packs a list of Package() objects into a number of equal-sized bins.

    Returns a list of bins listing the packages within the bins and a list of packages which can't be
    packed because they are to big."""
    if not bin:
        bin = Package("600x400x400")
    return allpermutations(packages, bin, iterlimit)


def test():
    fd = open('testdata.txt')
    vorher = 0
    nachher = 0
    start = time.time()
    for line in fd:
        packages = [Package(pack) for pack in line.strip().split()]
        if not packages:
            continue
        bins, rest = binpack(packages)
        if rest:
            print "invalid data", rest, line
        else:
            vorher += len(packages)
            nachher += len(bins)
    print time.time() - start,
    print vorher, nachher, float(nachher) / vorher * 100


if __name__ == '__main__':
    import cProfile
    cProfile.run('test()')


from pyshipping.package import Package


================================================
FILE: pyshipping/carriers/__init__.py
================================================
"""Function for specific freight carriers."""


================================================
FILE: pyshipping/carriers/dpd/__init__.py
================================================
"""Functions specific to DPD/Geopost."""


================================================
FILE: pyshipping/carriers/dpd/georoute.py
================================================
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
georoute.py - get DPD related routng information

Originally coded by md, cleand up and extended by jmv and then again reworked by md.
Copyright 2006, 2007 HUDORA GmbH. Published under a BSD License.
"""

import os
import os.path
import gzip
import logging
import sqlite3


ROUTETABLES_BASE = os.path.join(os.path.split(os.path.abspath(__file__))[0], 'georoutetables')
ROUTES_DB_BASE = '/tmp/dpdroutes'


# Quelle: http://de.wikipedia.org/wiki/Liste_der_Kfz-Nationalitätszeichen
ISO2CAR = {
    'AT': 'A',
    'BE': 'B',
    'FR': 'F',
}


class InvalidFormatError(Exception):
    """Invalid input file format."""
    pass


class GeorouteException(Exception):
    """Base class for all routing exceptions"""
    pass


class CountryError(GeorouteException):
    """Unknown country."""
    pass


class DepotError(GeorouteException):
    """Unknown depot."""
    pass


class ServiceError(GeorouteException):
    """Unknown service."""
    pass


class TranslationError(GeorouteException):
    """Cannot translate city and country to postcode."""
    pass


class RoutingDepotError(GeorouteException):
    """Unknown routing depot."""
    pass


class NoRouteError(GeorouteException):
    """Route not found."""
    pass


class Parcel(object):
    """Parcel destination data."""

    # depreciated
    def __init__(self, depot='142', service='101', country='DE', city=None, postcode=None):
        import warnings
        warnings.warn("Parcel() is deprecated", DeprecationWarning, stacklevel=2)

        self.service = service
        self.country = country
        self.city = city
        self.postcode = postcode


class Destination(object):
    """Parcel destination data."""

    def __init__(self, country='DE', postcode=None, city=None, service='101'):
        self.service = service
        self.country = country
        self.city = city
        self.postcode = postcode


class Route:
    """Output of the routing algorithm."""

    def __init__(self, d_depot, o_sort, d_sort, grouping_priority, barcode_id,
                 iata_code, service_text, service_mark, country, serviceinfo, countrynum,
                 routingtable_version, postcode):
        self.d_depot = d_depot
        self.o_sort = o_sort
        self.d_sort = d_sort
        self.grouping_priority = grouping_priority
        self.barcode_id = barcode_id
        self.iata_code = iata_code
        self.service_text = service_text
        self.service_mark = service_mark
        self.country = country
        self.serviceinfo = serviceinfo
        self.countrynum = countrynum
        self.routingtable_version = routingtable_version
        self.postcode = postcode

    def __unicode__(self):
        output = u"""Output parameters:
Country: %s
D-Depot: %s
O-Sort: %s
D-Sort: %s
Grouping priority: %s
Barcode ID: %s
ITA Code: %s
Service Text: %s""" % (self.country, self.d_depot, self.o_sort, self.d_sort,
                       self.grouping_priority, self.barcode_id, self.iata_code,
                       self.service_text)
        if self.service_mark:
            output += "\nService Mark: %s" % self.service_mark
        if self.iata_code:
            output += "\nIATA Code: %s" % self.iata_code
        if self.serviceinfo:
            output += "\nService Info: %s" % self.serviceinfo

        return output

    def __repr__(self):
        return repr(vars(self))

    def routingdata(self):
        return {'o_sort': self.o_sort, 'd_sort': self.d_sort,
                'd_depot': self.d_depot, 'country': self.country,
                'service_text': self.service_text, 'serviceinfo': self.serviceinfo}


def _readfile(filename):
    """Read file line-by-line skipping comments."""
    if os.path.exists(filename + '.gz'):
        fhandle = gzip.GzipFile(filename + '.gz')
    else:
        fhandle = file(filename)
    for line in fhandle:
        line = line.strip().decode('latin1')
        if line.startswith('#'):
            continue
        yield line.split('|')


class RouteData(object):
    """More convenient representation of the georoute data."""

    def __init__(self, routingdepot='0142'):
        """Routingdepot the depot from where you are sending."""
        self.routingdepot = routingdepot
        self.routingdepotgroups = ''
        self.routingdepotcountry = ''

        services = os.path.join(ROUTETABLES_BASE, 'SERVICE')
        self.version = None
        for line in file(services):
            if line.startswith('#Version: '):
                self.version = line.split(':')[1].strip()
                break
        if self.version is None:
            raise InvalidFormatError("There's no version in the SERVICE file")

        self.countries = {}
        for line in _readfile(os.path.join(ROUTETABLES_BASE, 'COUNTRY')):
            isonum, isoname = line[:2]
            self.countries[isoname.upper()] = isonum

        self.depots = {}
        for line in _readfile(os.path.join(ROUTETABLES_BASE, 'DEPOTS')):
            geopostdepotnumber = line[0]
            self.depots[geopostdepotnumber] = tuple(line)

        self.services = {}
        for line in _readfile(os.path.join(ROUTETABLES_BASE, 'SERVICE')):
            servicecode = line[0]
            self.services[servicecode] = tuple(line)

        self.serviceinfo = {}
        for line in _readfile(os.path.join(ROUTETABLES_BASE, 'SERVICEINFO.DE')):
            servicecode = line[0]
            self.serviceinfo[servicecode] = line[1]

        filename = ROUTES_DB_BASE + ('-%s-%s.db' % (routingdepot, self.version))
        self.db = sqlite3.connect(filename)

        self.read_depots(ROUTETABLES_BASE)
        self.read_locations(ROUTETABLES_BASE)
        self.read_routes(ROUTETABLES_BASE)

    def read_depots(self, path):
        """Read DEPOTS file and save all the information in a
        SQLite database."""
        c = self.db.cursor()

        c.execute("""SELECT COUNT(*)
                     FROM sqlite_master
                     WHERE type = 'table' AND name = 'depots'""")
        if not c.fetchone()[0]:
            logging.info("regenerating depots table")
            c.execute("""CREATE TABLE depots
            (DepotNumber TEXT PRIMARY KEY,
             IATACode TEXT,
             GroupId TEXT,
             Name1 TEXT,
             Name2 TEXT,
             Address1 TEXT,
             Address2 TEXT,
             Postcode TEXT,
             CityName TEXT,
             Country TEXT,
             Phone TEXT,
             Fax TEXT,
             Mail TEXT,
             Web TEXT)""")

            for line in _readfile(os.path.join(path, 'DEPOTS')):
                c.execute("""INSERT INTO depots
                             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                          line[:14])
                if line[0] == self.routingdepot:
                    self.routingdepotgroups = line[2]
                    self.routingdepotgrouplist = line[2].split(',')
                    self.routingdepotcountry = line[9]
            c.execute('VACUUM;')

    def read_locations(self, path):
        """Read LOCATION file and save all the information in a SQLite database."""
        c = self.db.cursor()

        c.execute("""SELECT COUNT(*)
                     FROM sqlite_master
                     WHERE type='table' AND name='location'""")
        if not c.fetchone()[0]:
            logging.info("regenerating location table")
            c.execute("""CREATE TABLE location
            (Area TEXT,
             City TEXT,
             Country TEXT,
             Postcode TEXT)""")

            for line in _readfile(os.path.join(path, 'LOCATION.DE')):
                c.execute('INSERT INTO location VALUES (?,?,?,?)',
                          line[:4])
            c.execute('VACUUM;')

    def read_routes(self, path):
        """Read ROUTES file and save all the information in a SQLite database."""
        # self.db = sqlite3.connect(ROUTES_DB)
        c = self.db.cursor()

        c.execute("""SELECT COUNT(*)
                     FROM sqlite_master
                     WHERE type='table' AND name='routes'""")
        if not c.fetchone()[0]:
            logging.info("regenerating routes table")
            c.execute("""CREATE TABLE routes
            (id INTEGER PRIMARY KEY,
            DestinationCountry TEXT,
            BeginPostCode TEXT,
            EndPostCode TEXT,
            ServiceCodes TEXT,
            RoutingPlaces TEXT,
            SendingDate TEXT,
            OSort TEXT,
            DDepot TEXT,
            GroupingPriority TEXT,
            DSort TEXT,
            BarcodeID TEXT)""")

            c.execute("""SELECT COUNT(*)
                         FROM sqlite_master
                         WHERE type='table' AND name='routedepots'""")
            if not c.fetchone()[0]:
                logging.info("regenerating routedepots table")
                c.execute("""CREATE TABLE routedepots
                (route INTEGER,
                 depot TEXT)""")

            c.execute("PRAGMA synchronous=OFF;")
            c.execute("PRAGMA temp_store=MEMORY;")
            i = 1
            for line in _readfile(os.path.join(path, 'ROUTES')):
                services = self.expand_services(line[3])
                c.execute('INSERT INTO routes VALUES (?,?,?,?,?,?,?,?,?,?,?,?)',
                          [i] + line[:3] + [services] + line[4:-1])
                self.expand_depots(i, line[4], c)
                i += 1

            c.execute("CREATE INDEX routes_DestinationCountry ON routes(DestinationCountry)")
            c.execute("CREATE INDEX routes_BeginPostCode ON routes(BeginPostCode)")
            c.execute("CREATE INDEX routes_EndPostCode ON routes(EndPostCode)")
            c.execute("CREATE INDEX routedepots_route ON routedepots(route)")
            c.execute("CREATE INDEX routedepots_depot ON routedepots(depot)")
            c.execute('VACUUM;')  # also commits the database

    def expand_services(self, services):
        """Expand services list."""
        services_list = []
        for service in services.split(','):
            if len(service) > 4:
                start = int(service[1:4])
                end = int(service[4:])
                for i in range(start, end + 1):
                    services_list.append(unicode(i))
            else:
                services_list.append(service[1:])

        return ','.join(services_list)

    def expand_depots(self, route, depots, c):
        """Parse depots list and generate route->depots relationship."""
        # but only four "our" depot.
        # if you change the self.routingdepot, you have to rebuild the database
        if depots == '':
            c.execute("""INSERT INTO routedepots(route, depot) VALUES (?, ?)""", (route, depots))
            return

        for depot in depots.split(','):
            if depot.startswith('C'):
                if depot[1:] == self.routingdepotcountry:
                    c.execute("""INSERT INTO routedepots(route, depot) VALUES(?, ?)""", (route,
                                                                                         self.routingdepot))
            elif depot.startswith('D'):
                if len(depot) > 5:
                    start = int(depot[1:5])
                    end = int(depot[5:])
                    for i in range(start, end + 1):
                        if ("%04d" % i) == self.routingdepot:
                            c.execute("""INSERT INTO routedepots(route, depot) VALUES(?, ?)""",
                                      (route, self.routingdepot))
                else:
                    if depot[1:5] == self.routingdepot:
                        c.execute("""INSERT INTO routedepots(route, depot) VALUES(?, ?)""",
                                  (route, depot[1:5]))
            elif depot.startswith('G'):
                if depot[1:] in self.routingdepotgroups:
                    c.execute("INSERT INTO routedepots(route, depot) VALUES(?, ?)",
                              (route, self.routingdepot))
            else:
                raise InvalidFormatError("Unable to parse depot '%s'" % depot)

    def get_countrynum(self, isoname):
        """Return country ISO code."""
        if not isoname.upper() in self.countries:
            raise CountryError("Country %s unknown" % isoname)
        return self.countries[isoname.upper()]

    def get_depot(self, depotnumber):
        """Return depot."""
        if not depotnumber in self.depots:
            raise DepotError("Depot %s unknown" % depotnumber)
        return self.depots[depotnumber]

    def get_service(self, servicecode):
        """Return service."""
        if not servicecode in self.services:
            raise ServiceError("Service %s unknown" % servicecode)
        return self.services[servicecode]

    def get_servicetext(self, servicecode):
        """Return service info to be printed on label."""
        if not servicecode in self.serviceinfo:
            return ''
        return self.serviceinfo[servicecode]

    def translate_location(self, city, country):
        """Return postcode for given city and country."""
        cur = self.db.cursor()
        cur.execute("SELECT Postcode FROM location WHERE City=? AND Country=?", (city, country))
        rows = cur.fetchall()
        if not rows:
            raise TranslationError("Cannot find postcode for location %s, %s" % (city, country))
        return rows[0][0]


class Router(object):
    """Routes parcels."""

    def __init__(self, data):
        self.route_data = data
        self.db = self.route_data.db

    def route(self, parcel):
        """Find route."""

        self.current_subset = []
        self.conditions = ['1=1']
        self.cleanup_postcode(parcel)

        self.select_country(parcel)
        if parcel.postcode is None:
            parcel.postcode = self.route_data.translate_location(parcel.city, parcel.country)
            self.subsetstack.append(self.subset)

        self.select_postcode(parcel)
        self.select_service(parcel)
        self.select_depot(parcel)
        # Sending date is not used yet, according to documentation

        # If there are several routes, always use the first one.
        # In prior versions, an exception was raised instead.
        if len(self.current_subset) >= 1:
            rows = self.select_routes("1=1")
            (service_text, service_mark) = self.route_data.get_service(parcel.service)[1:3]
            depot = self.route_data.get_depot(rows[0][8])
            iata_code = depot[1]
            country = depot[9]
            if not country:
                country = parcel.country
            serviceinfo = self.route_data.get_servicetext(parcel.service)

            return Route(rows[0][8], rows[0][7], rows[0][10], rows[0][9], rows[0][11],
                         iata_code, service_text, service_mark, country,
                         serviceinfo, self.route_data.get_countrynum(country),
                         self.route_data.version, parcel.postcode)
        raise NoRouteError("No route found for %r|%r|%r" % \
              (parcel.country, parcel.postcode, parcel.service))

    def add_condition(self, condition):
        self.conditions.append(condition)

    def select_routes(self, condition, params=()):
        """Find routes matching condition and currently selected subset of the routes table.
        If routes are found, save their ids for narrowing future searches.
        If no routes are found, do not change current subset.
        """

        subsetcondition = ' AND '.join(self.conditions)
        cur = self.db.cursor()
        cur.execute("SELECT * FROM routes WHERE %s AND %s" % (subsetcondition, condition), params)
        rows = cur.fetchall()

        # Save matched rows if there were any results
        if rows:
            self.add_condition(condition)
        self.current_subset = [unicode(row[0]) for row in rows]
        return rows

    def select_country(self, parcel):
        """Select all routes with the given country."""
        rows = self.select_routes("DestinationCountry='%s'" % (parcel.country.upper().replace("'", ''), ))
        if not rows:
            raise CountryError("Country %s unknown" % parcel.country)

    def cleanup_postcode(self, parcel):
        """Removes spaces and country prefixes from postcodes."""

        if not parcel.postcode:
            return
        parcel.postcode = parcel.postcode.replace(' ', '').strip()
        if parcel.postcode.startswith('-'):
            parcel.postcode = parcel.postcode[1:]
            self.cleanup_postcode(parcel)
        if parcel.postcode.upper().startswith(parcel.country.upper()):
            parcel.postcode = parcel.postcode[len(parcel.country):]
            self.cleanup_postcode(parcel)
        if parcel.country.upper() in ISO2CAR:
            if parcel.postcode.upper().startswith(ISO2CAR[parcel.country.upper()]):
                parcel.postcode = parcel.postcode[len(ISO2CAR[parcel.country.upper()]):]
                self.cleanup_postcode(parcel)
        if parcel.country.upper() == 'DE' and parcel.postcode.upper().startswith('CH-'):
            parcel.country = 'CH'
            parcel.postcode = parcel.postcode[2:]
            self.cleanup_postcode(parcel)
        if parcel.country.upper() == 'DE' and parcel.postcode.upper().startswith('BE-'):
            parcel.country = 'BE'
            parcel.postcode = parcel.postcode[2:]
            self.cleanup_postcode(parcel)
        if parcel.country.upper() == 'DE' and parcel.postcode.upper().startswith('B-'):
            parcel.country = 'BE'
            parcel.postcode = parcel.postcode[1:]
            self.cleanup_postcode(parcel)
        if parcel.country.upper() == 'DE' and parcel.postcode.upper().startswith('AT-'):
            parcel.country = 'AT'
            parcel.postcode = parcel.postcode[2:]
            self.cleanup_postcode(parcel)
        if parcel.country.upper() == 'DE' and parcel.postcode.upper().startswith('A-'):
            parcel.country = 'AT'
            parcel.postcode = parcel.postcode[1:]
            self.cleanup_postcode(parcel)

    def select_postcode(self, parcel):
        """Select all routes matching the given postcode."""

        # direct match
        rows = self.select_routes("BeginPostCode='%s'" % parcel.postcode.replace("'", ''))
        if not rows:
            # range
            rows = self.select_routes("BeginPostCode<='%s' AND EndPostCode>='%s'"
                                       % (parcel.postcode.replace("'", ''), parcel.postcode.replace("'", '')))
        if not rows:
            # catch all
            rows = self.select_routes("BeginPostCode=''")
        if not rows:
            raise NoRouteError("Postcode %r|%r unknown" % (parcel.country, parcel.postcode))

    def select_service(self, parcel):
        """Select all routes with the given service code."""

        # we have to redo postcode query as a backoff strategy
        self.conditions.pop()
        postcodequeries = ["BeginPostCode='%s'" % parcel.postcode.replace("'", ''),
            "BeginPostCode<='%s' AND EndPostCode>='%s'" % (parcel.postcode.replace("'", ''),
                                                           parcel.postcode.replace("'", '')),
            "BeginPostCode=''"]
        for postcodequery in postcodequeries:
            rows = self.select_routes("%s AND ServiceCodes LIKE '%%%s%%'" % (postcodequery, parcel.service))
            if not rows:
                # catch all
                rows = self.select_routes("%s AND ServiceCodes = ''" % (postcodequery))
            if rows:
                break
        if not rows:
            raise ServiceError("No route for service found %r|%r|%r unknown" % \
                (parcel.country, parcel.postcode, parcel.service))

    def select_depot(self, parcel):
        """Select all routes with the given depot."""
        subset = "route IN (%s)" % ','.join([unicode(route) for route in self.current_subset])
        cur = self.db.cursor()
        cur.execute("SELECT route FROM routedepots WHERE depot=%s AND %s" % (self.route_data.routingdepot,
                                                                             subset))
        rows = cur.fetchall()
        if not rows:
            cur.execute("SELECT route FROM routedepots WHERE %s" % (subset))
            rows = cur.fetchall()
        if not rows:
            raise RoutingDepotError("No route found for %r|%r|%r|%r|%r" % \
                  (parcel.country, parcel.postcode, parcel.service, self.route_data.routingdepot, subset))
        self.current_subset = [unicode(row[0]) for row in rows]


def get_route_without_cache(country=None, postcode=None, city=None, servicecode='101'):
    router = Router(RouteData())
    return router.route(Destination(country, postcode, city))


def get_route(country=None, postcode=None, city=None, servicecode='101'):
    # this includes somewhat overly complex caching
    filename = ROUTES_DB_BASE + ('_cache.db')
    cache_db = sqlite3.connect(filename, isolation_level=None)
    cur = cache_db.cursor()
    # ensure table exists
    cur.execute("""SELECT COUNT(*)
                 FROM sqlite_master
                 WHERE type = 'table' AND name = 'routing_cache'""")
    if not cur.fetchone()[0]:
        logging.info("regenerating cache table")
        cur.execute("""CREATE TABLE routing_cache
        (country_postcode_servicecode TEXT PRIMARY KEY,
        d_depot TEXT,
        o_sort TEXT,
        d_sort TEXT,
        grouping_priority TEXT,
        barcode_id TEXT,
        iata_code TEXT,
        service_text TEXT,
        service_mark TEXT,
        country TEXT,
        serviceinfo TEXT,
        countrynum TEXT,
        routingtable_version TEXT,
        postcode TEXT
        )""")

    # check if entry is cached
    cur.execute("SELECT * FROM routing_cache WHERE country_postcode_servicecode='%s'"
                 % ("%s_%s_%s" % (country, postcode, servicecode)))
    rows = cur.fetchall()
    if not rows:
        # nothing found
        route = get_route_without_cache(country, postcode, city, servicecode)
        cur.execute("""INSERT INTO routing_cache
                             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                             ("%s_%s_%s" % (country, postcode, servicecode),
                             route.d_depot,
                             route.o_sort,
                             route.d_sort,
                             route.grouping_priority,
                             route.barcode_id,
                             route.iata_code,
                             route.service_text,
                             route.service_mark,
                             route.country,
                             route.serviceinfo,
                             route.countrynum,
                             route.routingtable_version,
                             route.postcode))
        # For some reason closing the cache generated occasionally runtime errors.
        # cache_db.close()
    else:
        if len(rows) > 1:
            raise RuntimeError("to many cache hits!")
        route = Route(*rows[0][1:])
    return route


# compability layer to old georoute code prior to huLOG revision 1710

def find_route(depot, servicecode, land, plz):
    """Legacy method - to be removed."""

    import warnings
    warnings.warn("georoute.find_route() is deprecated use get_route() instead",
                  DeprecationWarning, stacklevel=2)

    if unicode(depot) != '0142':
        raise RuntimeError("wrong depot")
    return get_route(unicode(land), unicode(plz), servicecode=unicode(servicecode))


================================================
FILE: pyshipping/carriers/dpd/georoute_test.py
================================================
#!/usr/bin/env python
# -*- encoding: utf-8 -*-

"""Test routing resolver for DPD. Coded by jmv, extended by md"""

import time
import unittest
from pyshipping.carriers.dpd.georoute import get_route, get_route_without_cache
from pyshipping.carriers.dpd.georoute import RouteData, Router, Destination
from pyshipping.carriers.dpd.georoute import ServiceError, CountryError, TranslationError


class TestCase(unittest.TestCase):
    """Provide sophisticated dictionary comparision."""

    def assertDicEq(self, dict1, dict2):
        """Asserts if two dicts are unequal.

        Raise an Exception which mentions the different entries of those dicts.
        """
        if dict1 != dict2:
            difference = set()
            for key, value in dict1.items():
                if dict2.get(key) != value:
                    difference.add((key, value, dict2.get(key)))
            for key, value in dict2.items():
                if dict1.get(key) != value:
                    difference.add((key, dict1.get(key), value))
            raise self.failureException, \
                ('%r != %r: %s' % (dict1, dict2, list(difference)))


class RouteDataTest(TestCase):

    def setUp(self):
        self.data = RouteData()
        self.db = self.data.db

    def test_version(self):
        self.assertEqual(self.data.version, '20110905')

    def test_get_country(self):
        self.assertRaises(CountryError, self.data.get_countrynum, 'URW')
        self.assertEqual(self.data.get_countrynum('JP'), '392')
        self.assertEqual(self.data.get_countrynum('DE'), '276')
        self.assertEqual(self.data.get_countrynum('de'), '276')

    def test_read_depots(self):
        c = self.db.cursor()
        c.execute("""SELECT * FROM depots WHERE DepotNumber=?""", ('0015', ))
        rows = c.fetchall()
        self.assertEqual(1, len(rows))
        self.assertEqual((u'0015', u'', u'', u'Betriebsgesellschaft DPD GmbH',
                          u'', u'Otto-Hahn-Strasse 5', u'', u'59423', u'Unna', u'DE',
                          u'+49-(0) 23 03-8 88-0', u'+49-(0) 23 03-8 88-31', u'', u''),
                         rows[0])

    def test_expand_depots(self):
        c = self.db.cursor()
        c.execute("""SELECT id
                     FROM routes
                     WHERE DestinationCountry='DE' AND BeginPostCode='42477'""")
        rows = c.fetchall()
        # Interestingly we sometimes get two routes
        # self.assertEqual(1, len(rows))
        route = rows[0][0]
        c.execute("SELECT depot FROM routedepots WHERE route=?", (route, ))
        rows = c.fetchall()
        self.assertEqual(1, len(rows))

    def test_get_service(self):
        self.assertEqual(self.data.get_service('180'), ('180', 'AM1-NO', '', '022,160', ''))
        self.assertRaises(ServiceError, self.data.get_service, '100000')

    def test_get_servicetext(self):
        text = self.data.get_servicetext('185')
        self.assertEqual('DPD 10:00 Unfrei / ex works', text)

    def test_translate_location(self):
        self.assertEqual('1', self.data.translate_location('Dublin', 'IE'))
        self.assertRaises(TranslationError, self.data.translate_location, 'Cahir', 'IE')


class RouterTest(TestCase):

    def setUp(self):
        self.data = RouteData()
        self.router = Router(self.data)

    def test_known_routes_de(self):
        route = self.router.route(Destination(postcode='42477'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0142', 'serviceinfo': '', 'country': u'DE',
                                               'd_sort': u'65', 'o_sort': u'42', 'service_text': u'D'})
        route = self.router.route(Destination(postcode='42897'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0142', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': '15', 'o_sort': '42', 'service_text': 'D'})
        route = self.router.route(Destination(postcode='53111'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0150', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': u'205', 'o_sort': '50', 'service_text': 'D'})
        route = self.router.route(Destination(postcode='53111', country='DE'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0150', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': u'205', 'o_sort': '50', 'service_text': 'D'})
        route = self.router.route(Destination('DE', '53111'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0150', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': u'205', 'o_sort': '50', 'service_text': 'D'})
        route = self.router.route(Destination('DE', '53111', city='Bonn'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0150', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': u'205', 'o_sort': '50', 'service_text': 'D'})
        route = self.router.route(Destination('DE', '53111', 'Bonn'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0150', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': u'205', 'o_sort': '50', 'service_text': 'D'})

    def test_known_routes_world(self):
        route = self.router.route(Destination(postcode='66400', country='FR'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0470', 'serviceinfo': '', 'country': u'FR',
                                               'd_sort': u'U50', 'o_sort': u'16', 'service_text': u'D'})
        route = self.router.route(Destination('FR', '66400', 'Ceret'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0470', 'serviceinfo': '', 'country': 'FR',
                                               'd_sort': 'U50', 'o_sort': '16', 'service_text': 'D'})
        route = self.router.route(Destination('BE', '3960', 'Bree/Belgien'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0532', 'serviceinfo': '', 'country': 'BE',
                                               'd_sort': u'A353', 'o_sort': '52', 'service_text': 'D'})
        route = self.router.route(Destination('CH', '6005', 'Luzern'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0616', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '40', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '1210', 'Wien'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0622', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': '10', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '4820', 'Bad Ischl'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0624', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': '63', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '7400', 'Oberwart'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0628', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': u'3270', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '4400', 'Steyr'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0624', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': '70', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '1220', 'Wien'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0622', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': '30', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('AT', '6890', 'Lustenau'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0627', 'serviceinfo': '', 'country': 'AT',
                                               'd_sort': '01', 'o_sort': '62', 'service_text': 'D'})
        route = self.router.route(Destination('BE', '3520', 'ZONHOVEN'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0532', 'serviceinfo': '', 'country': u'BE',
                                               'd_sort': u'A369', 'o_sort': u'52', 'service_text': u'D'})
        route = self.router.route(Destination('BE', '4890', 'Thimister'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0532', 'serviceinfo': '', 'country': 'BE',
                                               'd_sort': u'B326', 'o_sort': '52', 'service_text': 'D'})
        route = self.router.route(Destination('CH', '8305', 'Dietlikon'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0615', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '77', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('CH', '4051', 'Basel'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0610', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': u'16', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('CH', '8808', 'Pf<C3><A4>ffikon'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0615', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '71', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('DK', '9500', 'Hobro'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0504', 'serviceinfo': '', 'country': 'DK',
                                               'd_sort': u'405', 'o_sort': '20', 'service_text': 'D'})
        # Lichtenstein is routed via CH
        route = self.router.route(Destination('LI', '8399', 'Windhof / Luxembourg'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0617', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('LI', '9495', 'Triesen'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0617', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('LI', '8440', 'Steinfort'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0617', 'serviceinfo': '', 'country': 'CH',
                                               'd_sort': '', 'o_sort': '78', 'service_text': 'D'})
        route = self.router.route(Destination('CZ', '41742', 'Krupka 1'))
        self.assertDicEq(route.routingdata(), {'d_depot': '1380', 'serviceinfo': '', 'country': 'CZ',
                                               'd_sort': '21', 'o_sort': '10', 'service_text': 'D'})
        route = self.router.route(Destination('ES', '28802', 'Alcala de Henares (Madrid)'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0728', 'serviceinfo': '', 'country': 'ES',
                                               'd_sort': '01', 'o_sort': '16', 'service_text': 'D'})
        route = self.router.route(Destination('ES', '28010', 'Madrid'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0728', 'serviceinfo': '', 'country': 'ES',
                                               'd_sort': '01', 'o_sort': '16', 'service_text': 'D'})
        route = self.router.route(Destination('FR', '84170', 'MONTEUX'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0447', 'serviceinfo': '', 'country': 'FR',
                                               'd_sort': u'S65', 'o_sort': '16', 'service_text': 'D'})
        route = self.router.route(Destination('FR', '91044', 'Evry Cedex'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0408', 'serviceinfo': '', 'country': u'FR',
                                               'd_sort': u'S61', 'o_sort': u'50', 'service_text': u'D'})

    def test_difficult_routingdepots(self):
        route = self.router.route(Destination('AT', '3626', 'H<C3><BC>nibach'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0623', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'01', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '8225', 'P<C3><B6>llau'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0628', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'1290', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '5020', 'Salzburg'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0625', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'1000', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('SE', '65224', 'Karlstad'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0307', 'serviceinfo': u'', 'country': 'SE',
                                               'd_sort': u'01', 'o_sort': u'20', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '2734', 'Buchberg/Schneeberg'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0621', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'64', 'o_sort': u'62', 'service_text': u'D'})

    def test_difficult_service(self):
        route = self.router.route(Destination('AT', '4240', 'Freistadt Österreich'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0634', 'serviceinfo': '', 'country': u'AT',
                                               'd_sort': u'22', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '5101', 'Bergheim bei Salzburg'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0625', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'2509', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '8230', 'Hartberg'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0628', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'1290', 'o_sort': u'62', 'service_text': u'D'})
        route = self.router.route(Destination('AT', '8045', 'Graz/<C3><96>sterreich'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0628', 'serviceinfo': u'', 'country': 'AT',
                                               'd_sort': u'2840', 'o_sort': u'62', 'service_text': u'D'})

    def test_postcode_with_country(self):
        route = self.router.route(Destination(postcode='FR-66400', country='FR'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0470', 'serviceinfo': '', 'country': u'FR',
                                               'd_sort': u'U50', 'o_sort': u'16', 'service_text': u'D'})
        route = self.router.route(Destination(postcode='FR 66400', country='FR'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0470', 'serviceinfo': '', 'country': u'FR',
                                               'd_sort': u'U50', 'o_sort': u'16', 'service_text': u'D'})
        route = self.router.route(Destination(postcode='FR66400', country='FR'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0470', 'serviceinfo': '', 'country': 'FR',
                                               'd_sort': 'U50', 'o_sort': '16', 'service_text': 'D'})
        route = self.router.route(Destination(postcode='F-66400', country='FR'))
        self.assertDicEq(route.routingdata(), {'d_depot': '0470', 'serviceinfo': '', 'country': 'FR',
                                               'd_sort': 'U50', 'o_sort': '16', 'service_text': 'D'})

    def test_postcode_spaces(self):
        route = self.router.route(Destination(postcode='42 477'))
        self.assertDicEq(route.routingdata(), {'o_sort': '42', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': '65', 'd_depot': '0142', 'service_text': 'D'})
        route = self.router.route(Destination(postcode=' 42477'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0142', 'serviceinfo': '', 'country': u'DE',
                                               'd_sort': u'65', 'o_sort': u'42', 'service_text': u'D'})
        route = self.router.route(Destination(postcode=' 42477 '))
        self.assertDicEq(route.routingdata(), {'d_depot': '0142', 'serviceinfo': '', 'country': 'DE',
                                               'd_sort': '65', 'o_sort': '42', 'service_text': 'D'})
        # real live sample
        route = self.router.route(Destination('GB', 'GU148HN', 'Hampshire'))
        self.assertDicEq(route.routingdata(), {'d_depot': '1550', 'serviceinfo': '', 'country': 'GB',
                                               'd_sort': '', 'o_sort': '52', 'service_text': 'D'})
        route = self.router.route(Destination('GB', 'GU 14 8HN', 'Hampshire'))
        self.assertDicEq(route.routingdata(), {'d_depot': '1550', 'serviceinfo': '', 'country': 'GB',
                                               'd_sort': '', 'o_sort': '52', 'service_text': 'D'})

    def test_problematic_routes(self):
        # Lichtenstein is problematic because usually it is routed trough Swizerland.
        route = self.router.route(Destination('LI', '8440'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0617', 'serviceinfo': '', 'country': u'CH',
                                               'd_sort': u'', 'o_sort': u'78', 'service_text': u'D'})
        route = self.router.route(Destination('LI', '8440', 'Steinfort'))
        self.assertDicEq(route.routingdata(), {'d_depot': u'0617', 'serviceinfo': '', 'country': u'CH',
                                               'd_sort': u'', 'o_sort': u'78', 'service_text': u'D'})

    def test_international(self):
        # AR   | 1426  | Buenos Aire
        self.assertDicEq(get_route('AR', '1426').routingdata(),
            {'d_depot': u'0920', 'serviceinfo': u'', 'country': u'AR', 'd_sort': u'', 'o_sort': u'16',
             'service_text': u'D'})
        # AZ   | 1073 | Baku
        self.assertDicEq(get_route('AZ', '1073').routingdata(),
            {'d_depot': u'0918', 'serviceinfo': '', 'country': 'AZ', 'd_sort': u'CDG', 'o_sort': u'16',
             'service_text': u'D'})
        # BE   | 3960 | Bree/Belgien
        self.assertDicEq(get_route('BE', '3960').routingdata(),
            {'d_depot': u'0532', 'serviceinfo': u'', 'country': u'BE', 'd_sort': u'A353', 'o_sort': u'52',
            'service_text': u'D'})
        # BG   | 1766 | Sofia
        self.assertDicEq(get_route('BG', '1766').routingdata(),
            {'d_depot': u'1660', 'serviceinfo': '', 'country': u'BG', 'd_sort': u'', 'o_sort': u'62', 'service_text': u'D'})
        # CH   | 3601 | Thun/Schweiz
        self.assertDicEq(get_route('CH', '3601').routingdata(),
            {'d_depot': u'0612', 'serviceinfo': u'', 'country': u'CH', 'd_sort': u'', 'o_sort': u'78',
            'service_text': u'D'})
        # CZ   | 16300 | Praha 6- Repy
        self.assertDicEq(get_route('CZ', '16300').routingdata(),
            {'d_depot': u'1391', 'serviceinfo': u'', 'country': u'CZ', 'd_sort': u'B854', 'o_sort': u'10',
            'service_text': u'D'})
        # CZ   | 71000 | Ostrava
        self.assertDicEq(get_route('CZ', '71000').routingdata(),
            {'d_depot': u'1384', 'serviceinfo': u'', 'country': u'CZ', 'd_sort': u'412', 'o_sort': u'10',
            'service_text': u'D'})
        # DE   | 04316 | Leipzig
        self.assertDicEq(get_route('DE', '04316').routingdata(),
            {'d_depot': u'0104', 'serviceinfo': '', 'country': u'DE', 'd_sort': u'2CPO', 'o_sort': u'10',
             'service_text': u'D'})
        # DE   | 99974 | M<C3><BC>hlhausen / Th<C3><BC>ringen
        self.assertDicEq(get_route('DE', '99974').routingdata(),
            {'d_depot': u'0234', 'serviceinfo': u'', 'country': u'DE', 'd_sort': u'C015', 'o_sort': u'KK02',
            'service_text': u'D'})
        # DK   | 4000  | Roskilde
        self.assertDicEq(get_route('DK', '4000').routingdata(),
            {'d_depot': u'0500', 'serviceinfo': u'', 'country': u'DK', 'd_sort': u'01', 'o_sort': u'20',
            'service_text': u'D'})
        # DK   | 9500   | Hobro
        self.assertDicEq(get_route('DK', '9500').routingdata(),
            {'d_depot': u'0504', 'serviceinfo': u'', 'country': u'DK', 'd_sort': u'405', 'o_sort': u'20',
            'service_text': u'D'})
        # EE   | 10621  | Tallinn
        self.assertDicEq(get_route('EE', '10621').routingdata(),
            {'d_depot': u'0560', 'serviceinfo': u'', 'country': u'EE', 'd_sort': u'0005', 'o_sort': u'13',
            'service_text': u'D'})
        # ES   | 08227  | Terrassa
        self.assertDicEq(get_route('ES', '08227').routingdata(),
            {'d_depot': u'0708', 'serviceinfo': u'', 'country': u'ES', 'd_sort': u'01', 'o_sort': u'16',
            'service_text': u'D'})
        # FI   | 94700  | Kemi
        self.assertDicEq(get_route('FI', '94700').routingdata(),
            {'d_depot': u'1614', 'serviceinfo': u'', 'country': u'FI', 'd_sort': u'510', 'o_sort': u'15',
            'service_text': u'D'})
        # FR   | 91044  | EVRY-LISSES
        self.assertDicEq(get_route('FR', '91044').routingdata(),
            {'d_depot': u'0408', 'serviceinfo': '', 'country': u'FR', 'd_sort': u'S61', 'o_sort': u'50',
             'service_text': u'D'})
        # GB   | BT387AR              | Carrickfergus
        self.assertDicEq(get_route('GB', 'BT387AR').routingdata(),
            {'d_depot': u'1598', 'serviceinfo': u'', 'country': u'GB', 'd_sort': u'', 'o_sort': u'52',
            'service_text': u'D'})
        # GB   | CB13SW               | Cambridge
        self.assertDicEq(get_route('GB', 'CB13SW').routingdata(),
            {'d_depot': u'1550', 'serviceinfo': u'', 'country': u'GB', 'd_sort': u'', 'o_sort': u'52',
            'service_text': u'D'})
        # GB   | G43 2DX              | Glasgow
        self.assertDicEq(get_route('GB', 'G43 2DX').routingdata(),
            {'d_depot': u'1550', 'serviceinfo': u'', 'country': u'GB', 'd_sort': u'', 'o_sort': u'52',
            'service_text': u'D'})
        # GB   | G432DX               | Glasgow
        self.assertDicEq(get_route('GB', 'G432DX').routingdata(),
            {'d_depot': u'1550', 'serviceinfo': u'', 'country': u'GB', 'd_sort': u'', 'o_sort': u'52',
            'service_text': u'D'})
        # GB   | N41NR                | London
        self.assertDicEq(get_route('GB', 'N41NR').routingdata(),
            {'d_depot': u'1550', 'serviceinfo': u'', 'country': u'GB', 'd_sort': u'', 'o_sort': u'52',
            'service_text': u'D'})
        # GR   | 17341  | Athens
        self.assertDicEq(get_route('GR', '17341').routingdata(),
            {'d_depot': u'1251', 'serviceinfo': u'', 'country': u'GR', 'd_sort': u'', 'o_sort': u'62',
            'service_text': u'D'})
        # GR   | 64200  | Chrisoupoli-KAVALA
        self.assertDicEq(get_route('GR', '64200').routingdata(),
            {'d_depot': u'1251', 'serviceinfo': u'', 'country': u'GR', 'd_sort': u'', 'o_sort': u'62',
            'service_text': u'D'})
        # HR   | 10000 | Zagreb
        self.assertDicEq(get_route('HR', '10000').routingdata(),
            {'d_depot': u'1750', 'serviceinfo': u'', 'country': u'HR', 'd_sort': u'SVI', 'o_sort': u'62',
            'service_text': u'D'})
        # HR   | 44000 | Sisak
        self.assertDicEq(get_route('HR', '44000').routingdata(),
            {'d_depot': u'1750', 'serviceinfo': u'', 'country': u'HR', 'd_sort': u'020', 'o_sort': u'62',
            'service_text': u'D'})
        # HU   | 1121  | Budapest
        self.assertDicEq(get_route('HU', '1121').routingdata(),
            {'d_depot': u'1640', 'serviceinfo': u'', 'country': u'HU', 'd_sort': u'027', 'o_sort': u'62',
            'service_text': u'D'})
        # HU   | 9400  | Sopron
        self.assertDicEq(get_route('HU', '9400').routingdata(),
            {'d_depot': u'1657', 'serviceinfo': u'', 'country': u'HU', 'd_sort': u'684', 'o_sort': u'62',
            'service_text': u'D'})
        # IT   | 34100    | Trieste / Italien
        self.assertDicEq(get_route('IT', '34100').routingdata(),
            {'d_depot': u'0835', 'serviceinfo': u'', 'country': u'IT', 'd_sort': u'01', 'o_sort': u'16',
            'service_text': u'D'})
        # LI   | 09494    | Schaan
        self.assertDicEq(get_route('LI', '09494').routingdata(),
            {'d_depot': u'0617', 'serviceinfo': u'', 'country': u'CH', 'd_sort': u'', 'o_sort': u'78',
            'service_text': u'D'})
        # LI   | 9999     | Wemperhardt
        self.assertDicEq(get_route('LI', '9999').routingdata(),
            {'d_depot': u'0617', 'serviceinfo': u'', 'country': u'CH', 'd_sort': u'', 'o_sort': u'78',
            'service_text': u'D'})
        # LI   | CH-9491  | Ruggell
        self.assertDicEq(get_route('LI', 'CH-9491').routingdata(),
            {'d_depot': u'0617', 'serviceinfo': u'', 'country': u'CH', 'd_sort': u'', 'o_sort': u'78',
            'service_text': u'D'})
        # LI   | 9491  | Ruggell
        self.assertDicEq(get_route('LI', '9491').routingdata(),
            {'d_depot': u'0617', 'serviceinfo': u'', 'country': u'CH', 'd_sort': u'', 'o_sort': u'78',
            'service_text': u'D'})
        # LT   | 3031     | Kaunas
        self.assertDicEq(get_route('LT', '3031').routingdata(),
            {'d_depot': u'0594', 'serviceinfo': '', 'country': u'LT', 'd_sort': u'732', 'o_sort': u'13',
             'service_text': u'D'})
        # LV   | 1039     | Riga
        self.assertDicEq(get_route('LV', '1039').routingdata(),
            {'d_depot': u'0575', 'serviceinfo': u'', 'country': u'LV', 'd_sort': u'R39', 'o_sort': u'13',
            'service_text': u'D'})
        # NL   | 7443TC   | Nijverdal
        self.assertDicEq(get_route('NL', '7443TC').routingdata(),
            {'d_depot': u'0512', 'serviceinfo': '', 'country': u'NL', 'd_sort': u'B535', 'o_sort': u'52',
             'service_text': u'D'})
        # NL   | 9405 JB  | Assen
        self.assertDicEq(get_route('NL', '9405 JB').routingdata(),
            {'d_depot': u'0513', 'serviceinfo': u'', 'country': u'NL', 'd_sort': u'B241', 'o_sort': u'52',
            'service_text': u'D'})
        # NO   | 6800     | Förde
        self.assertDicEq(get_route('NO', '6800').routingdata(),
            {'d_depot': u'0360', 'serviceinfo': u'', 'country': u'NO', 'd_sort': u'01', 'o_sort': u'15',
            'service_text': u'D'})
        # PL   | 80516    | Gdansk
        self.assertDicEq(get_route('PL', '80516').routingdata(),
            {'d_depot': u'1306', 'serviceinfo': u'', 'country': u'PL', 'd_sort': u'', 'o_sort': u'13',
            'service_text': u'D'})
        # PL   | 22300    | Krasnystaw
        self.assertDicEq(get_route('PL', '22300').routingdata(),
            {'d_depot': u'1300', 'serviceinfo': u'', 'country': u'PL', 'd_sort': u'', 'o_sort': u'13',
            'service_text': u'D'})
        # SE   | 11358    | Stockholm
        self.assertDicEq(get_route('SE', '11358').routingdata(),
            {'d_depot': u'0312', 'serviceinfo': u'', 'country': u'SE', 'd_sort': u'01', 'o_sort': u'20',
            'service_text': u'D'})
        # SE   | 75752    | Uppsala
        self.assertDicEq(get_route('SE', '75752').routingdata(),
            {'d_depot': u'0312', 'serviceinfo': u'', 'country': u'SE', 'd_sort': u'01', 'o_sort': u'20',
            'service_text': u'D'})
        # SI   | 1225     | Lukovica
        self.assertDicEq(get_route('SI', '1225').routingdata(),
            {'d_depot': u'1696', 'serviceinfo': '', 'country': u'SI', 'd_sort': u'14', 'o_sort': u'62',
             'service_text': u'D'})
        # SK   | 82105    | Bratislava
        self.assertDicEq(get_route('SK', '82105').routingdata(),
            {'d_depot': u'0660', 'serviceinfo': '', 'country': u'SK', 'd_sort': u'10', 'o_sort': u'10',
             'service_text': u'D'})

    def test_incorrectCountry(self):
        self.assertRaises(CountryError, get_route, 'URG', '42477')

    def test_incorrectLocation(self):
        self.assertRaises(TranslationError, get_route, 'DE', None)

    def test_incorrectService(self):
        self.assertRaises(ServiceError, get_route, 'DE', '0001')

    def test_select_routes(self):
        self.router.conditions = ['1=1']
        rows = self.router.select_routes('DestinationCountry=?', ('UZ', ))
        self.assert_(len(rows) > 0)

    def test_cache(self):
        self.assertDicEq(vars(get_route('LI', '8440')), vars(get_route_without_cache('LI', '8440')))


class HighLevelTest(TestCase):

    def test_get_route(self):
        self.assertDicEq(vars(get_route('DE', '42897')),
            {'service_mark': u'', 'o_sort': u'42', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'DE', 'countrynum': u'276',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'15',
             'postcode': u'42897', 'd_depot': u'0142', 'service_text': u'D'})
        self.assertDicEq(vars(get_route('DE', '42897', 'Remscheid')),
            {'service_mark': u'', 'o_sort': u'42', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'DE', 'countrynum': u'276',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'15',
             'postcode': u'42897', 'd_depot': u'0142', 'service_text': u'D'})
        self.assertDicEq(vars(get_route('DE', '42897', 'Remscheid', '101')),
            {'service_mark': u'', 'o_sort': u'42', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'DE', 'countrynum': u'276',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'15',
             'postcode': u'42897', 'd_depot': u'0142', 'service_text': u'D'})
        self.assertDicEq(vars(get_route('LI', '8440')),
            {'service_mark': u'', 'o_sort': u'78', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'CH', 'countrynum': u'756',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'',
             'postcode': u'8440', 'd_depot': u'0617', 'service_text': u'D'})
        self.assertDicEq(vars(get_route(u'LI', '8440')),
            {'service_mark': u'', 'o_sort': u'78', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'CH', 'countrynum': u'756',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'',
             'postcode': u'8440', 'd_depot': u'0617', 'service_text': u'D'})
        self.assertDicEq(vars(get_route(u'LI', u'8440')),
            {'service_mark': u'', 'o_sort': u'78', 'serviceinfo': u'', 'barcode_id': u'37',
             'grouping_priority': u'', 'country': u'CH', 'countrynum': u'756',
             'routingtable_version': u'20110905', 'iata_code': u'', 'd_sort': u'',
             'postcode': u'8440', 'd_depot': u'0617', 'service_text': u'D'})

    def test_cache(self):
        self.assertEqual(vars(get_route('LI', '8440')), vars(get_route_without_cache('LI', '8440')))

if __name__ == '__main__':
    start = time.time()
    router = Router(RouteData())
    stamp = time.time()
    router.route(Destination('AT', '4240', 'Freistadt Österreich')).routingdata()
    end = time.time()
    # print ("took %.3fs to find a single route (including %.3fs initialisation overhead)"
    #        % (end-start, stamp-start))

    unittest.main()


================================================
FILE: pyshipping/carriers/dpd/georoutetables/COUNTRY
================================================
#Filename: COUNTRY
#Version: 20140505
#Expiration: 20140831
#Hash: 01f9fd1927280385e2afd8287ca19c8528cb4ad2
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: ISO-NumCountryCode|ISO-Alpha2CountryCode|ISO-Alpha3CountryCode|DestinationLanguages|FlagPostCodeNo|
#Key: ISO-NumCountryCode|
004|AF|AFG|EN|0|
008|AL|ALB|SQ|0|
010|AQ|ATA|EN|1|
012|DZ|DZA|FR|0|
016|AS|ASM|EN|0|
020|AD|AND|FR,ES,CA|0|
024|AO|AGO|PT|1|
028|AG|ATG|EN|1|
031|AZ|AZE|AZ|0|
032|AR|ARG|ES|0|
036|AU|AUS|EN|0|
040|AT|AUT|DE|0|
044|BS|BHS|EN|1|
048|BH|BHR|AR|0|
050|BD|BGD|BN,EN|0|
051|AM|ARM|HY|0|
052|BB|BRB|EN|1|
056|BE|BEL|FR,NL,DE|0|
060|BM|BMU|EN|0|
064|BT|BTN|DZ|0|
068|BO|BOL|ES,AY,QU|1|
070|BA|BIH|BS,HR,SR|0|
072|BW|BWA|EN|0|
074|BV|BVT|NO,EN|1|
076|BR|BRA|PT|0|
084|BZ|BLZ|EN|0|
086|IO|IOT|EN|0|
090|SB|SLB|EN|1|
092|VG|VGB|EN|0|
096|BN|BRN|MS,EN|0|
100|BG|BGR|BG|0|
104|MM|MMR|MY|0|
108|BI|BDI|FR,RN|1|
112|BY|BLR|BE,RU|0|
116|KH|KHM|KM|0|
120|CM|CMR|FR,EN|0|
124|CA|CAN|EN,FR|0|
132|CV|CPV|PT|0|
136|KY|CYM|EN|0|
140|CF|CAF|FR,SG|0|
144|LK|LKA|SI,TA,EN|0|
148|TD|TCD|FR,AR|1|
152|CL|CHL|ES|0|
156|CN|CHN|ZH|0|
158|TW|TWN|EN|0|
162|CX|CXR|EN|1|
166|CC|CCK|EN|0|
170|CO|COL|ES|1|
174|KM|COM|FR,AR|0|
175|YT|MYT|FR,MG,SW|0|
178|CG|COG|FR,LN|0|
180|CD|COD|FR|0|
184|CK|COK|EN|0|
188|CR|CRI|ES|0|
191|HR|HRV|HR|0|
192|CU|CUB|ES|0|
196|CY|CYP|EL,TR|0|
203|CZ|CZE|CS|0|
204|BJ|BEN|FR|0|
208|DK|DNK|DA|0|
212|DM|DMA|EN|0|
214|DO|DOM|ES|0|
218|EC|ECU|ES,QU|0|
222|SV|SLV|ES|1|
226|GQ|GNQ|ES,FR|1|
231|ET|ETH|AM|0|
232|ER|ERI|AR,TI,EN|0|
233|EE|EST|ET|0|
234|FO|FRO|FO|0|
238|FK|FLK|EN|0|
239|GS|SGS|EN|0|
242|FJ|FJI|EN|0|
246|FI|FIN|FI,SV|0|
248|AX|ALA|SV|0|
250|FR|FRA|FR|0|
254|GF|GUF|FR,EN|0|
258|PF|PYF|FR,TY|0|
260|TF|ATF|FR,EN|1|
262|DJ|DJI|FR,AR,AA|1|
266|GA|GAB|FR|0|
268|GE|GEO|KA|0|
270|GM|GMB|EN|1|
275|PS|PSE|AR,EN|0|
276|DE|DEU|DE|0|
288|GH|GHA|EN|1|
292|GI|GIB|ES,EN|1|
296|KI|KIR|EN|1|
300|GR|GRC|EL,EN|0|
304|GL|GRL|DA|0|
308|GD|GRD|EN|1|
312|GP|GLP|FR|0|
316|GU|GUM|EN|0|
320|GT|GTM|ES|0|
324|GN|GIN|FR|0|
328|GY|GUY|EN|0|
332|HT|HTI|FR,HT|0|
334|HM|HMD|EN|1|
336|VA|VAT|IT|0|
340|HN|HND|ES|0|
344|HK|HKG|EN,ZH|1|
348|HU|HUN|HU,EN|0|
352|IS|ISL|IS,EN|0|
356|IN|IND|EN,HI|0|
360|ID|IDN|ID|0|
364|IR|IRN|FA|0|
368|IQ|IRQ|AR,KU|0|
372|IE|IRL|EN,GA|0|
376|IL|ISR|AR,HE|0|
380|IT|ITA|IT|0|
384|CI|CIV|FR|0|
388|JM|JAM|EN|1|
392|JP|JPN|JA,EN|0|
398|KZ|KAZ|KK,RU|0|
400|JO|JOR|AR|0|
404|KE|KEN|EN,SW|0|
408|KP|PRK|KO|1|
410|KR|KOR|KO|0|
414|KW|KWT|AR|0|
417|KG|KGZ|UZ,KY,RU|0|
418|LA|LAO|LO|0|
422|LB|LBN|AR,EN,FR|1|
426|LS|LSO|EN|0|
428|LV|LVA|LV|0|
430|LR|LBR|EN|0|
434|LY|LBY|AR|0|
438|LI|LIE|DE|0|
440|LT|LTU|LT|0|
442|LU|LUX|LB,FR,DE|0|
446|MO|MAC|PT,ZH|1|
450|MG|MDG|MG,FR,EN|0|
454|MW|MWI|EN|1|
458|MY|MYS|MS|0|
462|MV|MDV|DV|0|
466|ML|MLI|FR|1|
470|MT|MLT|MT,EN|0|
474|MQ|MTQ|FR|0|
478|MR|MRT|AR|1|
480|MU|MUS|EN,FR|0|
484|MX|MEX|ES|0|
492|MC|MCO|FR|0|
496|MN|MNG|MN|0|
498|MD|MDA|MO|0|
499|ME|MNE|SR|0|
500|MS|MSR|EN|1|
504|MA|MAR|AR|0|
508|MZ|MOZ|PT|0|
512|OM|OMN|AR|0|
516|NA|NAM|AF,EN|1|
520|NR|NRU|NA|1|
524|NP|NPL|NE|0|
528|NL|NLD|NL|0|
530|AN|ANT|NL|1|
531|CW|CUW|EN,NL|1|
533|AW|ABW|EN|1|
534|SX|SXM|EN,NL|1|
535|BQ|BES|NL|1|
540|NC|NCL|FR|0|
548|VU|VUT|FR,EN|0|
554|NZ|NZL|EN|0|
558|NI|NIC|ES|0|
562|NE|NER|FR|0|
566|NG|NGA|EN|0|
570|NU|NIU|EN|1|
574|NF|NFK|EN|1|
578|NO|NOR|NO,NB,NN|0|
580|MP|MNP|EN|1|
581|UM|UMI|EN|1|
583|FM|FSM|EN|0|
584|MH|MHL|EN|1|
585|PW|PLW|EN|0|
586|PK|PAK|EN|0|
591|PA|PAN|ES|1|
598|PG|PNG|EN|0|
600|PY|PRY|ES,GN|0|
604|PE|PER|ES,QU,AY|0|
608|PH|PHL|EN|0|
612|PN|PCN|EN|0|
616|PL|POL|PL|0|
620|PT|PRT|PT|0|
624|GW|GNB|PT|0|
626|TL|TLS|PT,ID|1|
630|PR|PRI|ES,EN|0|
634|QA|QAT|AR|1|
638|RE|REU|FR|0|
642|RO|ROU|RO|0|
643|RU|RUS|RU|0|
646|RW|RWA|FR,EN,RW|1|
654|SH|SHN|EN|0|
659|KN|KNA|EN|1|
660|AI|AIA|EN|1|
662|LC|LCA|EN|1|
663|MF|MAF|FR|0|
666|PM|SPM|FR|0|
670|VC|VCT|EN|1|
674|SM|SMR|IT|0|
678|ST|STP|PT|1|
682|SA|SAU|AR|0|
686|SN|SEN|FR|0|
688|RS|SRB|SR|0|
690|SC|SYC|FR,EN|1|
694|SL|SLE|EN|1|
702|SG|SGP|EN,MS,TA|0|
703|SK|SVK|SK|0|
704|VN|VNM|VI|0|
705|SI|SVN|SL|0|
706|SO|SOM|SO,EN|0|
710|ZA|ZAF|AF,EN|0|
716|ZW|ZWE|EN|1|
724|ES|ESP|ES|0|
728|SS|SSD|EN|0|
729|SD|SDN|AR,EN|0|
732|EH|ESH|AR,ES,FR|0|
740|SR|SUR|EN,NL|1|
744|SJ|SJM|NO|0|
748|SZ|SWZ|EN,SS|0|
752|SE|SWE|SV|0|
756|CH|CHE|DE,FR,IT|0|
760|SY|SYR|AR|0|
762|TJ|TJK|TG|0|
764|TH|THA|TH|0|
768|TG|TGO|FR|1|
772|TK|TKL|EN|0|
776|TO|TON|EN,TO|1|
780|TT|TTO|EN|0|
784|AE|ARE|AR|1|
788|TN|TUN|AR|0|
792|TR|TUR|TR|0|
795|TM|TKM|TK|0|
796|TC|TCA|EN|0|
798|TV|TUV|EN|1|
800|UG|UGA|EN,SW|1|
804|UA|UKR|UK,RU|0|
807|MK|MKD|MK|0|
818|EG|EGY|AR|0|
826|GB|GBR|EN|0|
831|GG|GGY|EN|0|
832|JE|JEY|EN|0|
833|IM|IMN|EN|0|
834|TZ|TZA|EN,SW|1|
840|US|USA|EN|0|
850|VI|VIR|EN|0|
854|BF|BFA|FR|0|
858|UY|URY|ES|0|
860|UZ|UZB|UZ|0|
862|VE|VEN|ES|0|
876|WF|WLF|FR|0|
882|WS|WSM|SM|1|
887|YE|YEM|AR|0|
894|ZM|ZMB|EN|0|
991|IC|ISC|ES|0|
999|ZZ|ZZZ|EN|0|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/LOCATION.DE
================================================
#Filename: LOCATION.DE
#Version: 20140505
#Expiration: 20140831
#Hash: 6eedc807e450c4e8a76ee039ff22226d38b95f30
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: AreaName|CityName|ISO-Alpha2CountryCode|PostCode|
#Key: AreaName|CityName|
|Dublin|IE|1|
|Irland ohne Dublin|IE|2|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/LOCATION.EN
================================================
#Filename: LOCATION.EN
#Version: 20140505
#Expiration: 20140831
#Hash: 6f7eff135d73b9bf60bc6d9c983313d8811fbcb2
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: AreaName|CityName|ISO-Alpha2CountryCode|PostCode|
#Key: AreaName|CityName|
|Dublin|IE|1|
|Ireland excluding Dublin|IE|2|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/LOCATION.FR
================================================
#Filename: LOCATION.FR
#Version: 20140505
#Expiration: 20140831
#Hash: 71ba3db7983f8bcfa2a1b1cd327572ffcafaa331
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: AreaName|CityName|ISO-Alpha2CountryCode|PostCode|
#Key: AreaName|CityName|
|Dublin|IE|1|
|Reste de l'Irlande (sauf Dublin)|IE|2|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICE
================================================
#Filename: SERVICE
#Version: 20140505
#Expiration: 20140831
#Hash: c8aa7333314e4057f7cf43d42ec66e9f89588345
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: ServiceCode|ServiceText|ServiceMark|ServiceElements|
#Key: ServiceCode|
101|D||001|
102|D-HAZ||001,150|
103|D-6||001,130|
104|D-6-HAZ||001,130,150|
105|D-EXW||001,110|
106|D-EXW-HAZ||001,110,150|
107|D-6-EXW||001,110,130|
108|D-6-EXW-HAZ||001,110,130,150|
109|D-COD||001,100|
110|D-COD-HAZ||001,100,150|
111|D-6-COD||001,100,130|
112|D-6-COD-HAZ||001,100,130,150|
113|D-SWAP||001,120|
114|D-SWAP-HAZ||001,120,150|
115|D-6-SWAP||001,120,130|
116|D-6-SWAP-HAZ||001,120,130,150|
117|D||001,170|
118|D-BACK||001,121|
119|D-BACK-HAZ||001,121,150|
120|D+||001,180|
121|D-HAZ+||001,150,180|
122|D-6+||001,130,180|
123|D-6-HAZ+||001,130,150,180|
124|D-EXW+||001,110,180|
125|D-EXW-HAZ+||001,110,150,180|
126|D-6-EXW+||001,110,130,180|
127|D-6-EXW-HAZ+||001,110,130,150,180|
128|D-COD+||001,100,180|
129|D-COD-HAZ+||001,100,150,180|
130|D-6-COD+||001,100,130,180|
131|D-6-COD-HAZ+||001,100,130,150,180|
132|D-SWAP+||001,120,180|
133|D-SWAP-HAZ+||001,120,150,180|
134|D-6-SWAP+||001,120,130,180|
135|D-6-SWAP-HAZ+||001,120,130,150,180|
136|D|X|002|
137|D-6|X|002,130|
138|D-EXW|X|002,110|
139|D-6-EXW|X|002,110,130|
140|D-COD|X|002,100|
141|D-6-COD|X|002,100,130|
142|D-SWAP|X|002,120|
143|D-6-SWAP|X|002,120,130|
144|D|X|002,170|
145|D-BACK|X|002,121|
146|D+|X|002,180|
147|D-6+|X|002,130,180|
148|D-EXW+|X|002,110,180|
149|D-6-EXW+|X|002,110,130,180|
150|D-COD+|X|002,100,180|
151|D-6-COD+|X|002,100,130,180|
152|D-SWAP+|X|002,120,180|
153|D-6-SWAP+|X|002,120,130,180|
154|PARCELLetter|X|005|
155|PM2||010|
156|PM2-NO||010,160|
157|PM2-HAZ||010,150|
158|PM2-EXW||010,110|
159|PM2-EXW-NO||010,110,160|
160|PM2-EXW-HAZ||010,110,150|
161|PM2-COD||010,100|
162|PM2-COD-NO||010,100,160|
163|PM2-COD-HAZ||010,100,150|
164|PM2-SWAP||010,120|
165|PM2-SWAP-HAZ||010,120,150|
166|PM2-BACK||010,121|
167|PM2-BACK-HAZ||010,121,150|
168|PM2+||010,180|
169|PM2-NO+||010,160,180|
170|PM2-HAZ+||010,150,180|
171|PM2-EXW+||010,110,180|
172|PM2-EXW-NO+||010,110,160,180|
173|PM2-EXW-HAZ+||010,110,150,180|
174|PM2-COD+||010,100,180|
175|PM2-COD-NO+||010,100,160,180|
176|PM2-COD-HAZ+||010,100,150,180|
177|PM2-SWAP+||010,120,180|
178|PM2-SWAP-HAZ+||010,120,150,180|
179|AM1||022|
180|AM1-NO||022,160|
181|AM1-HAZ||022,150|
182|AM1-6||022,130|
183|AM1-6-NO||022,130,160|
184|AM1-6-HAZ||022,130,150|
185|AM1-EXW||022,110|
186|AM1-EXW-NO||022,110,160|
187|AM1-EXW-HAZ||022,110,150|
188|AM1-6-EXW||022,110,130|
189|AM1-6-EXW-NO||022,110,130,160|
190|AM1-6-EXW-HAZ||022,110,130,150|
191|AM1-COD||022,100|
192|AM1-COD-NO||022,100,160|
193|AM1-COD-HAZ||022,100,150|
194|AM1-6-COD||022,100,130|
195|AM1-6-COD-NO||022,100,130,160|
196|AM1-6-COD-HAZ||022,100,130,150|
197|AM1-SWAP||022,120|
198|AM1-SWAP-HAZ||022,120,150|
199|AM1-6-SWAP||022,120,130|
200|AM1-6-SWAP-HAZ||022,120,130,150|
201|AM1-BACK||022,121|
202|AM1-BACK-HAZ||022,121,150|
203|AM1+||022,180|
204|AM1-NO+||022,160,180|
205|AM1-HAZ+||022,150,180|
206|AM1-6+||022,130,180|
207|AM1-6-NO+||022,130,160,180|
208|AM1-6-HAZ+||022,130,150,180|
209|AM1-EXW+||022,110,180|
210|AM1-EXW-NO+||022,110,160,180|
211|AM1-EXW-HAZ+||022,110,150,180|
212|AM1-6-EXW+||022,110,130,180|
213|AM1-6-EXW-NO+||022,110,130,160,180|
214|AM1-6-EXW-HAZ+||022,110,130,150,180|
215|AM1-COD+||022,100,180|
216|AM1-COD-NO+||022,100,160,180|
217|AM1-COD-HAZ+||022,100,150,180|
218|AM1-6-COD+||022,100,130,180|
219|AM1-6-COD-NO+||022,100,130,160,180|
220|AM1-6-COD-HAZ+||022,100,130,150,180|
221|AM1-SWAP+||022,120,180|
222|AM1-SWAP-HAZ+||022,120,150,180|
223|AM1-6-SWAP+||022,120,130,180|
224|AM1-6-SWAP-HAZ+||022,120,130,150,180|
225|AM2||023|
226|AM2-NO||023,160|
227|AM2-HAZ||023,150|
228|AM2-6||023,130|
229|AM2-6-NO||023,130,160|
230|AM2-6-HAZ||023,130,150|
231|AM2-EXW||023,110|
232|AM2-EXW-NO||023,110,160|
233|AM2-EXW-HAZ||023,110,150|
234|AM2-6-EXW||023,110,130|
235|AM2-6-EXW-NO||023,110,130,160|
236|AM2-6-EXW-HAZ||023,110,130,150|
237|AM2-COD||023,100|
238|AM2-COD-NO||023,100,160|
239|AM2-COD-HAZ||023,100,150|
240|AM2-6-COD||023,100,130|
241|AM2-6-COD-NO||023,100,130,160|
242|AM2-6-COD-HAZ||023,100,130,150|
243|AM2-SWAP||023,120|
244|AM2-SWAP-HAZ||023,120,150|
245|AM2-6-SWAP||023,120,130|
246|AM2-6-SWAP-HAZ||023,120,130,150|
247|AM2-BACK||023,121|
248|AM2-BACK-HAZ||023,121,150|
249|AM2+||023,180|
250|AM2-NO+||023,160,180|
251|AM2-HAZ+||023,150,180|
252|AM2-6+||023,130,180|
253|AM2-6-NO+||023,130,160,180|
254|AM2-6-HAZ+||023,130,150,180|
255|AM2-EXW+||023,110,180|
256|AM2-EXW-NO+||023,110,160,180|
257|AM2-EXW-HAZ+||023,110,150,180|
258|AM2-6-EXW+||023,110,130,180|
259|AM2-6-EXW-NO+||023,110,130,160,180|
260|AM2-6-EXW-6-HAZ+||023,110,130,150,180|
261|AM2-COD+||023,100,180|
262|AM2-COD-NO+||023,100,160,180|
263|AM2-COD-HAZ+||023,100,150,180|
264|AM2-6-COD+||023,100,130,180|
265|AM2-6-COD-NO+||023,100,130,160,180|
266|AM2-6-COD-HAZ+||023,100,130,150,180|
267|AM2-SWAP+||023,120,180|
268|AM2-SWAP-HAZ+||023,120,150,180|
269|AM2-6-SWAP+||023,120,130,180|
270|AM2-6-SWAP-HAZ+||023,120,130,150,180|
271|SD||040|
272|SD-HAZ||040,150|
273|SD-EXW||040,110|
274|SD-EXW-HAZ||040,110,150|
275|SD-COD||040,100|
276|SD-COD-HAZ||040,100,150|
277|SD-SWAP||040,120|
278|SD-SWAP-HAZ||040,120,150|
279|SD-BACK||040,121|
280|SD-BACK-HAZ||040,121,150|
281|SD+||040,180|
282|SD-HAZ+||040,150,180|
283|SD-EXW+||040,110,180|
284|SD-EXW-HAZ+||040,110,150,180|
285|SD-COD+||040,100,180|
286|SD-COD-HAZ+||040,100,150,180|
287|SD-SWAP+||040,120,180|
288|SD-SWAP-HAZ+||040,120,150,180|
289|STANDARD BAG||060|
290|MAIL BAG||005,060|
291|IP||080|
292|POD BOX||081|
293|EXPRESS BAG||020,060|
294|MAIL||006,060|
298|RETURN SENDER||070,071|
299|RETURN|E|020,070|
300|RETURN||070|
301|RETURN-HAZ||070,150|
302|IE2|E|030|
303|IE2-MPS|E|030,140|
304|IE2-6|E|030,130|
305|IE2-6-MPS|E|030,130,140|
306|IE2-SWAP|E|030,120|
307|IE2-SWAP-MPS|E|030,120,140|
308|IE2-6-SWAP|E|030,120,130|
309|IE2-6-SWAP-MPS|E|030,120,130,140|
310|IE2-COD|E|030,100|
311|IE2-COD-MPS|E|030,100,140|
312|IE2-6-COD|E|030,100,130|
313|IE2-6-COD-MPS|E|030,100,130,140|
314|IE1|E|031|
325|D||001,012|
326|D|X|002,012|
327|D-B2C||001,013|
328|D-B2C|X|002,013|
329|D-COD-B2C||001,013,100|
330|D-COD-B2C|X|002,013,100|
331|D-TYRE UNP||001,014|
332|RETURN||072|
333|D-B2C+||001,013,180|
334|D-B2C+|X|002,013,180|
335|D-COD-B2C+||001,013,100,180|
336|D-COD-B2C+|X|002,013,100,180|
337|D-B2C-PSD||001,013,200|
338|D-B2C-PSD|X|002,013,200|
340|DPD MAX||090|
341|D-B2C-COD-PSD||001,013,100,200|
342|D-B2C-COD-PSD|X|002,013,100,200|
350|AM0||021|
351|AM0-EXW||021,110|
352|AM0-COD||021,100|
353|AM0-SWAP||021,120|
354|AM0-BACK||021,121|
355|AM0+||021,180|
356|AM0-EXW+||021,110,180|
357|AM0-COD+||021,100,180|
358|AM0-SWAP+||021,120,180|
359|D||001,190|
360|D|X|002,190|
361|D||001,110,190|
362|D|X|002,110,190|
363|D||001,210|
364|D|X|002,210|
365|D-TYRE||001,240|
366|D-TYRE-B2C||001,240,013|
367|D-TYRE-COD||001,240,100|
800|EXP||020|
801|EXP-COD||020,100|
802|EXP-EXW||020,110|
803|PS||610|
804|PS-COD||610,100|
805|PS-EXP||610,020|
806|D-SWAP-B2C+||001,013,120,180|
807|D-6-SWAP-B2C+||001,013,120,130,180|
808|D-SWAP-COD-B2C+||001,013,100,120,180|
809|D6-SWAP-COD-B2C+||001,013,100,120,130,180|
810|AM1||022|
811|AM2||023|
812|PM2||010|
813|TFR||600|
814|AM1-6||022,130|
815|AM2-6||023,130|
816|FIX||601|
817|PRIVAT||602|
818|D-SWAP-COD+||001,100,120,180|
819|D-6-SWAP-COD+||001,100,120,130,180|
820|D-6-B2C+||001,013,130,180|
821|D-6-B2C+|X|002,013,130,180|
822|D-6-COD-B2C+||001,013,100,130,180|
823|D-6-COD-B2C+|X|002,013,100,130,180|
824|D-ECO||001,250|
825|DPD MAX||090|
826|DPD MAX - COD||090,100|
827|D-SWAP-B2C||001,013,120|
828|D-SWAP-B2C|X|002,013,120|
829|D-6-B2C||001,013,130|
830|D-6-B2C|X|002,013,130|
831|D-6-COD-B2C||001,013,100,130|
832|D-6-COD-B2C|X|002,013,100,130|
833|D-6-SWAP-B2C||001,013,120,130|
834|D-6-SWAP-B2C|X|002,013,120,130|
835|D-SWAP-COD-B2C||001,013,100,120|
836|D-SWAP-COD-B2C|X|002,013,100,120|
837|D-6-SWAP-COD-B2C||001,013,100,120,130|
838|D-6-SWAP-COD-B2C|X|002,013,100,120,130|
839|D-EVE||001,220|
840|D-EVE|X|002,220|
841|D-COD-EVE||001,100,220|
842|D-COD-EVE|X|002,100,220|
843|SPAL||230|
844|D-B2C-PRIV||001,013,620|
845|D-B2C-PRIV|X|002,013,620|
846|D-B2C-HOME||001,013,621|
847|D-B2C-HOME|X|002,013,621|
848|D-SWAP-COD||001,100,120|
849|D-ECO-COD||001,250,100|
850|AM2-ECH-SHOP-NO||023,529,511,160|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICEINFO.CS
================================================
#Filename: SERVICEINFO.CS
#Version: 20140505
#Expiration: 20140831
#Hash: 755fd81761d0474d68f00ff70ce4516fa8fef173
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: ServiceCode|ServiceFieldInfo|
#Key: ServiceCode|
102|nebezpecne zbozi / hazardous goods|
103|sobota /saturday|
106|ex works nebezpecne zbozi / ex works hazardous goods|
109|dobirka / C.O.D.|
110|dobirka nebezpecne zbozi / C.O.D. hazardous goods|
113|vymena / exchange|
117|Collection-upon-Delivery|
121|nebezpecne zbozi / hazardous goods|
124|ex works|
125|ex works nebezpecne zbozi / ex works hazardous goods|
128|dobirka / C.O.D.|
129|dobirka  nebezpecne zbozi / C.O.D. hazardous goods|
132|vymena / exchange|
137|sobota / saturday|
138|ex works|
140|dobirka / C.O.D.|
142|vymena / exchange|
144|Collection-upon-Delivery|
148|ex works|
150|dobirka / C.O.D.|
152|vymena / exchange|
154|DPD PARCELLetter|
155|DPD 18:00 / DPD GUARANTEE|
158|DPD 18:00 ex works / DPD GUARANTEE ex works|
161|DPD 18:00 dobirka / DPD GUARANTEE C.O.D.|
164|DPD 18:00 vymena / DPD GUARANTEE exchange|
168|DPD 18:00 / DPD GUARANTEE|
171|DPD 18:00 ex works / DPD GUARANTEE ex works|
174|DPD 18:00 dobirka / DPD GUARANTEE C.O.D.|
179|DPD 10:00|
185|DPD 10:00 ex works|
191|DPD 10:00 dobirka / C.O.D.|
197|DPD 10:00 vymena / exchange|
203|DPD 10:00|
209|DPD 10:00 ex works|
215|DPD 10:00 dobirka / C.O.D.|
225|DPD 12:00|
228|DPD 12:00 sobota / Saturday|
231|DPD 12:00 ex works|
234|DPD 12:00 sobota ex works / Saturday ex works|
237|DPD 12:00 dobirka / C.O.D.|
240|DPD 12:00 sobota dobirka / Saturday C.O.D.|
243|DPD 12:00 vymena  / exchange|
249|DPD 12:00|
252|DPD 12:00 sobota / Saturday|
255|DPD 12:00 ex works|
258|DPD 12:00 sobota ex works / Saturday ex works|
261|DPD 12:00 dobirka / C.O.D.|
271|stejny den / same day|
327|PRIVATE ADDRESS / B2C|
328|PRIVATE ADDRESS / B2C|
329|PRIVATE ADDRESS / B2C - C.O.D.|
330|PRIVATE ADDRESS / B2C - C.O.D.|
333|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
334|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
335|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
336|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
352|DPD 8:30 dobirka / C.O.D.|
353|DPD 8:30 vymena / exchange|
357|DPD 8:30 dobirka / C.O.D.|
358|DPD 8:30 vymena / exchange|
839|VECERNI DORUCENI 17:00-20:00|
840|VECERNI DORUCENI 17:00-20:00|
841|VECERNI DORUCENI 17:00-20:00 DOBIRKA|
842|VECERNI DORUCENI 17:00-20:00 DOBIRKA|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICEINFO.CZ
================================================
#Filename: SERVICEINFO.CZ
#Version: 20110905
#Expiration: 20120101
#Hash: de42bef2636b38cd7f371000f71df64f66cc0eda
#Reference: http://extranet.dpd.de/georoute/references_dpd_20110905.txt
#Fields: ServiceCode|ServiceFieldInfo|
#Key: ServiceCode|
102|nebezpecne zbozi / hazardous goods|
103|sobota /saturday|
106|ex works nebezpecne zbozi / ex works hazardous goods|
109|dobirka / C.O.D.|
110|dobirka nebezpecne zbozi / C.O.D. hazardous goods|
113|vymena / exchange|
117|Collection-upon-Delivery|
121|nebezpecne zbozi / hazardous goods|
124|ex works|
125|ex works nebezpecne zbozi / ex works hazardous goods|
128|dobirka / C.O.D.|
129|dobirka  nebezpecne zbozi / C.O.D. hazardous goods|
132|vymena / exchange|
137|sobota / saturday|
138|ex works|
140|dobirka / C.O.D.|
142|vymena / exchange|
144|Collection-upon-Delivery|
148|ex works|
150|dobirka / C.O.D.|
152|vymena / exchange|
154|DPD PARCELLetter|
155|DPD 18:00 / DPD GUARANTEE|
158|DPD 18:00 ex works / DPD GUARANTEE ex works|
161|DPD 18:00 dobirka / DPD GUARANTEE C.O.D.|
164|DPD 18:00 vymena / DPD GUARANTEE exchange|
168|DPD 18:00 / DPD GUARANTEE|
171|DPD 18:00 ex works / DPD GUARANTEE ex works|
174|DPD 18:00 dobirka / DPD GUARANTEE C.O.D.|
179|DPD 10:00|
185|DPD 10:00 ex works|
191|DPD 10:00 dobirka / C.O.D.|
197|DPD 10:00 vymena / exchange|
203|DPD 10:00|
209|DPD 10:00 ex works|
215|DPD 10:00 dobirka / C.O.D.|
225|DPD 12:00|
228|DPD 12:00 sobota / Saturday|
231|DPD 12:00 ex works|
234|DPD 12:00 sobota ex works / Saturday ex works|
237|DPD 12:00 dobirka / C.O.D.|
240|DPD 12:00 sobota dobirka / Saturday C.O.D.|
243|DPD 12:00 vymena  / exchange|
249|DPD 12:00|
252|DPD 12:00 sobota / Saturday|
255|DPD 12:00 ex works|
258|DPD 12:00 sobota ex works / Saturday ex works|
261|DPD 12:00 dobirka / C.O.D.|
271|stejny den / same day|
327|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
328|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
329|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
330|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
333|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
334|SOUKROMA ADRESA / KONTAKTOVAT PRIJEMCE|
335|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
336|SOUKROMA ADRESA DOBIRKA / KONTAKTOVAT PRIJEMCE|
352|DPD 8:30 dobirka / C.O.D.|
353|DPD 8:30 vymena / exchange|
357|DPD 8:30 dobirka / C.O.D.|
358|DPD 8:30 vymena / exchange|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICEINFO.DE
================================================
#Filename: SERVICEINFO.DE
#Version: 20140505
#Expiration: 20140831
#Hash: 8124d0f60be0fe5c28a7f0af019c975fc2bd3542
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: ServiceCode|ServiceFieldInfo|
#Key: ServiceCode|
102|Gefahrgut / hazardous goods|
103|Samstag / saturday|
105|Unfrei / ex works|
106|Unfrei / ex works Gefahrgut / hazardous goods|
109|Nachnahme / C.O.D.|
110|Nachnahme / C.O.D. Gefahrgut / hazardous goods|
113|Austausch / exchange|
117|Mitnahme/Collection-upon-Delivery|
121|Gefahrgut / hazardous goods|
124|Unfrei / ex works|
125|Unfrei / ex works Gefahrgut / hazardous goods|
128|Nachnahme / C.O.D.|
129|Nachnahme / C.O.D. Gefahrgut / hazardous goods|
132|Austausch / exchange|
137|Samstag / saturday|
138|Unfrei / ex works|
140|Nachnahme / C.O.D.|
142|Austausch / exchange|
144|Mitnahme/Collection-upon-Delivery|
148|Unfrei / ex works|
150|Nachnahme / C.O.D.|
152|Austausch / exchange|
154|DPD PARCELLetter|
155|DPD 18:00 / DPD GUARANTEE|
158|DPD 18:00 / DPD GUARANTEE Unfrei / ex works|
161|DPD 18:00 / DPD GUARANTEE Nachnahme / C.O.D.|
164|DPD 18:00 / DPD GUARANTEE Austausch / exchange|
168|DPD 18:00 / DPD GUARANTEE|
171|DPD 18:00 / DPD GUARANTEE Unfrei / ex works|
174|DPD 18:00 / DPD GUARANTEE Nachnahme / C.O.D.|
179|DPD 10:00|
185|DPD 10:00 Unfrei / ex works|
191|DPD 10:00 Nachnahme / C.O.D.|
197|DPD 10:00 Austausch / exchange|
203|DPD 10:00|
209|DPD 10:00 Unfrei / ex works|
215|DPD 10:00 Nachnahme / C.O.D.|
225|DPD 12:00|
228|DPD 12:00 Samstag / saturday|
231|DPD 12:00 Unfrei / ex works|
234|DPD 12:00 Samstag / saturday Unfrei / ex works|
237|DPD 12:00 Nachnahme / C.O.D.|
240|DPD 12:00 Samstag / saturday Nachnahme / C.O.D.|
243|DPD 12:00 Austausch / exchange|
249|DPD 12:00|
252|DPD 12:00 Samstag / saturday|
255|DPD 12:00 Unfrei / ex works|
258|DPD 12:00 Samstag / saturday Unfrei / ex works|
261|DPD 12:00 Nachnahme / C.O.D.|
264|DPD 12:00 Samstag / saturday Nachnahme / C.O.D.|
270|DPD 12:00 Samstag Austausch Gefahrgut / Saturday Swap Hazardous Goods|
271|same day|
294|DPD Mail|
302|DPD EXPRESS|
325|EXPRESS ECONOMY|
326|EXPRESS ECONOMY|
329|Nachnahme / C.O.D.|
330|Nachnahme / C.O.D.|
335|Nachnahme / C.O.D.|
336|Nachnahme / C.O.D.|
337|DPD PaketShop Zustellung / Parcel Shop Delivery|
338|DPD PaketShop Zustellung / Parcel Shop Delivery|
341|DPD PaketShop Zustellung Nachnahme / Parcel Shop Delivery C.O.D.|
342|DPD PaketShop Zustellung Nachnahme / Parcel Shop Delivery C.O.D.|
350|DPD 8:30|
351|DPD 8:30 Unfrei / ex works|
352|DPD 8:30 Nachnahme / C.O.D.|
353|DPD 8:30 Austausch / exchange|
354|DPD 8:30|
355|DPD 8:30|
356|DPD 8:30 Unfrei / ex works|
357|DPD 8:30 Nachnahme / C.O.D.|
358|DPD 8:30 Austausch / exchange|
361|Unfrei / ex works|
362|Unfrei / ex works|
365|Reifen / Tyre|
366|Reifen / Tyre B2C|
367|Reifen / Tyre Nachnahme / C.O.D.|
810|Service Werktag 09:00 Uhr|
811|Service Werktag 12:00 Uhr|
812|Service Werktag 17:00 Uhr|
813|Service Werktag Zeitfenster|
814|Service Samstag 09:00 Uhr|
815|Service Samstag 12:00 Uhr|
816|Service Fixtermin|
817|Privatpaket|
820|Samstag / saturday|
821|Samstag / saturday|
822|Samstag / saturday Nachnahme / C.O.D.|
823|Samstag / saturday Nachnahme / C.O.D.|
827|Austausch / exchange|
828|Austausch / exchange|
829|Samstag / saturday|
830|Samstag / saturday|
831|Samstag / saturday Nachnahme / C.O.D.|
832|Samstag / saturday Nachnahme / C.O.D.|
833|Samstag / saturday Austausch / exchange|
834|Samstag / saturday Austausch / exchange|
835|Austausch / exchange Nachnahme / C.O.D.|
836|Austausch / exchange Nachnahme / C.O.D.|
837|Samstag / saturday Austausch / exchange Nachnahme / C.O.D.|
838|Samstag / saturday Austausch / exchange Nachnahme / C.O.D.|
839|Abendzustellung / Evening Delivery|
840|Abendzustellung / Evening Delivery|
841|Abendzustellung Nachnahme / Evening Delivery C.O.D.|
842|Abendzustellung Nachnahme / Evening Delivery C.O.D.|
844|Consumer Home|
845|Consumer Home|
846|Consumer Home & Shop|
847|Consumer Home & Shop|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICEINFO.EE
================================================
#Filename: SERVICEINFO.EE
#Version: 20110905
#Expiration: 20120101
#Hash: d8d55ca2e78b6aad2ecb2a4169dd58b108007c6e
#Reference: http://extranet.dpd.de/georoute/references_dpd_20110905.txt
#Fields: ServiceCode|ServiceFieldInfo|
#Key: ServiceCode|
102|hazardous goods|
103|saturday|
105|ex works|
106|ex works / hazardous goods|
109|Lunapakk (COD)|
110|Lunapakk (COD) / hazardous goods|
113|exchange|
117|Collection-upon-Delivery|
121|hazardous goods|
124|ex works|
125|ex works / hazardous goods|
128|Lunapakk (COD)|
129|Lunapakk (COD) / hazardous goods|
132|exchange|
137|saturday|
138|ex works|
140|Lunapakk (COD)|
142|exchange|
144|Collection-upon-Delivery|
148|ex works|
150|Lunapakk (COD)|
152|exchange|
154|DPD PARCELLetter|
155|DPD GUARANTEE|
158|DPD GUARANTEE ex works|
161|DPD GUARANTEE Lunapakk (COD)|
164|DPD GUARANTEE exchange|
168|DPD GUARANTEE|
171|DPD GUARANTEE ex works|
174|DPD GUARANTEE Lunapakk (COD)|
179|DPD 10:00|
185|DPD 10:00 ex works|
191|DPD 10:00 Lunapakk (COD)|
197|DPD 10:00 exchange|
203|DPD 10:00|
209|DPD 10:00 ex works|
215|DPD 10:00 Lunapakk (COD)|
225|DPD 12:00|
228|DPD 12:00 saturday|
231|DPD 12:00 ex works|
234|DPD 12:00 saturday / ex works|
237|DPD 12:00 Lunapakk (COD)|
240|DPD 12:00 saturday / Lunapakk (COD)|
243|DPD 12:00 exchange|
249|DPD 12:00|
252|DPD 12:00 saturday|
255|DPD 12:00 ex works|
258|DPD 12:00 saturday / ex works|
261|DPD 12:00 Lunapakk (COD)|
264|DPD 12:00 saturday / Lunapakk (COD)|
271|same day|
294|DPD Mail|
302|DPD EXPRESS|
325|EXPRESS ECONOMY|
326|EXPRESS ECONOMY|
329|Lunapakk (COD)|
330|Lunapakk (COD)|
335|Lunapakk (COD)|
336|Lunapakk (COD)|
350|DPD 8:30|
351|DPD 8:30 ex works|
352|DPD 8:30 Lunapakk (COD)|
353|DPD 8:30 exchange|
354|DPD 8:30|
355|DPD 8:30|
356|DPD 8:30 ex works|
357|DPD 8:30 Lunapakk (COD)|
358|DPD 8:30 exchange|
820|saturday|
821|saturday|
822|saturday / Lunapakk (COD)|
823|saturday / Lunapakk (COD)|
827|exchange|
828|exchange|
829|saturday|
830|saturday|
831|saturday / Lunapakk (COD)|
832|saturday / Lunapakk (COD)|
833|saturday / exchange|
834|saturday / exchange|
835|exchange / Lunapakk (COD)|
836|exchange / Lunapakk (COD)|
837|saturday / exchange / Lunapakk (COD)|
838|saturday / exchange / Lunapakk (COD)|
840|1 day transit time|
841|2 days transit time|
842|3 days transit time|
843|4 days transit time|
844|5 days transit time|
845|1 day transit time / Lunapakk (COD)|
846|2 days transit time / Lunapakk (COD)|
847|3 days transit time / Lunapakk (COD)|
848|4 days transit time / Lunapakk (COD)|
849|5 days transit time / Lunapakk (COD)|


================================================
FILE: pyshipping/carriers/dpd/georoutetables/SERVICEINFO.EN
================================================
#Filename: SERVICEINFO.EN
#Version: 20140505
#Expiration: 20140831
#Hash: 85037002df19b84563bcfdbc1153cd85ff629e9f
#Reference: http://extranet.dpd.de/georoute/references_dpd_20140505.txt
#Fields: ServiceCode|ServiceFieldInfo|
#Key: ServiceCode|
102|hazardous goods|
103|saturday|
105|ex works|
106|ex works / hazardous goods|
109|C.O.D.|
110|C.O.D. / hazardous goods|
113|exchange|
117|Collection-upon-Delivery|
121|hazardous goods|
124|ex works|
125|ex works / hazardous goods|
128|C.O.D.|
129|C.O.D. / hazardous goods|
132|exchange|
137|saturday|
138|ex works|
140|C.O.D.|
142|exchange|
144|Collection-upon-Delivery|
148|ex works|
150|C.O.D.|
152|exchange|
154|DPD PARCELLetter|
155|DPD GUARANTEE|
158|DPD GUARANTEE ex works|
161|DPD GUARANTEE C.O.D.|
164|DPD GUARANTEE exchange|
168|DPD GUARANTEE|
171|DPD GUARANTEE ex works|
174|DPD GUARANTEE C.O.D.|
179|DPD 10:00|
185|DPD 10:00 ex works|
191|DPD 10:00 C.O.D.|
197|DPD 10:00 exchange|
203|DPD 10:00|
209|DPD 10:00 ex works|
215|DPD 10:00 C.O.D.|
225|DPD 12:00|
228|DPD 12:00 saturday|
231|DPD 12:00 ex works|
234|DPD 12:00 saturday / ex works|
237|DPD 12:00 C.O.D.|
240|DPD 12:00 saturday / C.O.D.|
243|DPD 12:00 exchange|
249|DPD 12:00|
252|DPD 12:00 saturday|
255|DPD 12:00 ex works|
258|DPD 12:00 saturday / ex works|
261|DPD 12:00 C.O.D.|
264|DPD 12:00 saturday / C.O.D.|
270|DPD 12:00 Saturday Swap Hazardous Goods|
271|same day|
294|DPD Mail|
302|DPD EXPRESS|
325|EXPRESS ECONOMY|
326|EXPRESS ECONOMY|
329|C.O.D.|
330|C.O.D.|
335|C.O.D.|
336|C.O.D.|
337|Parcel Shop Delivery|
338|Parcel Shop Delivery|
341|Parcel Shop Delivery C.O.D.|
342|Parcel Shop Delivery C.O.D.|
350|DPD 8:30|
351|DPD 8:30 ex works|
352|DPD 8:30 C.O.D.|
353|DPD 8:30 exchange|
354|DPD 8:30|
355|DPD 8:30|
356|DPD 8:30 ex works|
357|DPD 8:30 C.O.D.|
358|DPD 8:30 exchange|
361|ex works|
362|ex works|
365|Tyre|
366|Tyre B2C|
367|Tyre C.O.D.|
820|saturday|
821|saturday|
822|saturday / C.O.D.|
823|saturday / C.O.D.|
827|exchange|
828|exchange|
829|saturday|
830|saturday|
831|saturday / C.O.D.|
832|saturday / C.O.D.|
833|saturday / exchange|
834|saturday / exchange|
835|exchange / C.O.D.|
836|exchange / C.O.D.|
837|saturday / exchange / C.O.D.|
838|saturday / exchange / C.O.D.|
839|Evening Delivery|
840|Evening Delivery|
841|Evening Delivery COD|
842|Evening Delivery COD|
843|Special Pallet|
844|Consumer Home|
845|Consumer Home|
846|Consumer Home & Shop|
847|Consumer Home & Shop|
848|4 days transit time / C.O.D.|
849|5 days transit time / C.O.D.|


================================================
FILE: pyshipping/fortras/__init__.py
================================================
"""This module contains tools for reading and writing Fortras messages. Fortras is a EDI standard for
logistics related information somewhat common in Germany. See http://de.wikipedia.org/wiki/Fortras for further
enlightenment."""

# You may consider this BSD licensed.

from pyshipping.fortras.bordero import ship
__all__ = [ship]


================================================
FILE: pyshipping/fortras/bordero.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
bordero.py - implements BORD messages. BORD is similar to IFTMIN in EDIFACT. Think of it as an work order
to a freight forwarder.

This implementation is specific for usage between HUDORA GmbH and Mäuler but could be used as the basis for a
more generic implementation.

Created by Lars Ronge and Maximillian Dornseif on 2006-11-06.
You may consider this BSD licensed.
"""

import os
import time


#def _transcode(data):
#    """Decode utf-8 to latin1 (which is used by fortras)."""
#    return data.decode('utf-8', 'replace').encode('latin-1', 'replace')


def _clip(length, data):
    """Clip a string to a maximum length."""
    # I wonder if this can't be done with clever formatstring usage.
    if not isinstance(data, str):
        data = data.decode('latin-1')
    if len(data) > length:
        return data[:length]
    return data

# zwei führende Nullen weg !!!
# übertragung: "übergepackt"
# übertragung: Palettenformat 1.5, 1, 0.5
# überticragung: lieferfenster
# DFü: Teil- Und Komplettladungen - verkehrsartschluessel : statt L (LKW) ein X (komplettladung)
# Mäuler Telefonummer
# Liste Auslandssendungen

#doctext = """Bordero-Kopf-Satz"""
#Afelder = [
#    dict(length=18, startpos=0,   endpos=19, name='borderonr',       fieldclass=IntegerFieldZeropadded),
#    dict(length=8,  startpos=19,  endpos=27, name='datum',           fieldclass=DateFieldReverse,
#         default=datetime.date.today()),
#    dict(length=1,  startpos=27,  endpos=28,  name='versandweg',     fieldclass=RightAdjustedField,
#         default='L', choices=('L', 'X')),
#    dict(length=2,  startpos=28,  endpos=30,  name='fahrzeugnummer', fieldclass=IntegerFieldZeropadded),
#    dict(length=10, startpos=34,  endpos=44,  name='versenderid',    fieldclass=RightAdjustedField,
#          default='L515'),
#    dict(length=13, startpos=44,  endpos=57,  name='frachtfuehrer',  fieldclass=RightAdjustedField,
#          default='Maeuler'),
#    dict(length=9,  startpos=53,  endpos=63,  name='plz',            fieldclass=RightAdjustedField,
#          default='42897'),
#    dict(length=12, startpos=63,  endpos=76,  name='ort',            fieldclass=RightAdjustedField,
#          default='Remscheid'),
#    dict(length=15, startpos=76,  endpos=91,  name='ladeeinheit1',   fieldclass=RightAdjustedField),
#    dict(length=15, startpos=91,  endpos=106, name='ladeeinheit1',   fieldclass=RightAdjustedField),
#    dict(length=10, startpos=106, endpos=117, name='plombe1',        fieldclass=RightAdjustedField),
#    dict(length=10, startpos=117, endpos=127, name='plombe1',        fieldclass=RightAdjustedField),
#    dict(length=10, startpos=117, endpos=127, name='release',        fieldclass=FixedField, default='6'),
#]
# Verkehrsartschlüssel (Satzart ‘A’, Position 031)
# B = Bahn
# E = Bordero für den eigenen Nahverkehr
# H = VP an ZKP
# K = Kombi
# L = LKW
# P = Packmittel-Clearing
# W = Weiterleitungsbordero
# X = Teilladungs-/Ladungspartie
# Y = Bordero ZKP an EB ohne Weiterverladung
# Z = ZKP an EP
# C = Codis
# N = Night Star Express
# S = SystemPlus international
# T = Teppichkurier


#doctext="""Versender-Adress-Satz - Teil 1"""
#Bfelder = [
#    dict(length=35, startpos= 0 , endpos= 35, name='versender_name1', default='HUDORA GmbH'),
#    dict(length=35, startpos= 35, endpos= 70, name='versender_name2'),
#    dict(length=35, startpos= 70, endpos=105, name='versender_strasse', default='Jägerwald 13'),
#    dict(length= 3, startpos=105, endpos=107, name='versender_land', default='DE'),
#    dict(length= 9, startpos=107, endpos=116, name='versender_plz', default='42897'),
#    dict(length= 3, startpos=116, endpos=119, name='frei', fieldclass=FixedField, default='   '),
#    dict(length= 3, startpos=119, endpos=122, name='codis_abholstelle', fieldclass=FixedField, default='   '),
#    dict(length= 1, startpos=122, endpos=123, name='codis_laufkennzeichen',
#         fieldclass=FixedField, default=' '),
#]
#
#doctext="""Versender-Adress-Satz - Teil 2"""
#Cfelder = [
#    dict(length=35, startpos=  0, endpos= 35, name='versenderort'),
#    dict(length= 3, startpos= 35, endpos= 38, name='versender_berechnungsland', fieldclass=FixedField,
#         default='   '),
#    dict(length= 9, startpos= 38, endpos= 48, name='versender_berechnugnsplz', fieldclass=FixedField,
#         default='         '),
#    dict(length=35, startpos= 48, endpos= 83, name='versender_berechnungsort', fieldclass=FixedField,
#         default='                                   '),
#    dict(length=17, startpos= 83, endpos=100, name='versender_kundennummer', fieldclass=RightAdjustedField,
#         default='11515'),
#    dict(length= 9, startpos=100, endpos=109, name='warenwert', fieldclass=DecimalFieldWithoutDot, precision=2),
#    dict(length= 3, startpos=109, endpos=112, name='waehrung', default='EUR'),
#    dict(length=13, startpos=112, endpos=123, name='frei', fieldclass=FixedField, default='             '),
#]
#
#doctext = """Empfänger-Adress-Satz  - Teil 1"""
#Dfelder = [
#    dict(length=35, startpos=  0, endpos= 35, name='name1'),
#    dict(length=35, startpos= 35, endpos= 70, name='name2'),
#    dict(length=35, startpos= 70, endpos=105, name='stadtteil'),
#    dict(length=19, startpos=105, endpos=123, name='frei'),
#]
#
#doctext = """Empfänger-Adress-Satz - Teil 2"""
#Efelder = [
#    dict(length=25, startpos=  0, endpos= 35, name='strasse'),
#    dict(length= 3, startpos= 35, endpos= 38, name='land'),
#    dict(length= 9, startpos= 38, endpos= 47, name='plz'),
#    dict(length=35, startpos= 47, endpos= 81, name='Empfängerort muss'),
#    dict(length= 3, startpos= 81, endpos= 84, name='Zustellbezirk Empfänger'),
#    dict(length=10, startpos= 84, endpos= 94, name='Matchcode Empfänger- Nachname'),
#    dict(length=17, startpos= 94, endpos=111, name='Kunden-Nr. Empfänger'),
#    dict(length=10, startpos=111, endpos=121, name='Original-ID des VP beim  Empfangspartner*'),
#    dict(length= 2, startpos=123, endpos=123, name='Frei'),
#]
#
#dictext="""Sendungs-Positions-Satz (je Sendungsteil; mehrfach möglich)."""
#Ffelder = [
#    dict(kength= 4, startpos=  0, endpos=  4, name='packstueck_anzahl'),
#    dict(kength= 2, startpos=  4, endpos=  6, name='verpackungsart'), # ???
#    dict(kength= 4, startpos=  6, endpos= 10, name='packstueck_anzahl_auf_paletten', fieldclass=FixedField,
#         default='    '),
#    dict(kength= 2, startpos= 10, endpos= 12, name='verpackungsart_auf_paletten', fieldclass=FixedField,
#         default='  '),
#    dict(kength=20, startpos= 10, endpos= 30, name='wareninhalt'),
#    dict(kength=20, startpos= 30, endpos= 50, name='zeichen',
#         doc="Zeichen der Sendung beim Versender"),
#    dict(kength= 5, startpos= 50, endpos= 55, name='gewicht', fieldclass=IntegerField,
#         doc="Bruttogewicht in KG."),
#    dict(kength= 5, startpos= 55, endpos= 60, name='gewicht_frachtpflichtig', fieldclass=IntegerField,
#         doc="In der Regel max(gewicht, N), wobei N=150 oder 200"),
#    # Die Satzart ‘F’ darf nicht mit einem 2. Sendungsteil versehen werden,
#    # wenn die Satzarten ‘G’ bzw. ‚Y‘ und ‚Z‘ (Gefahrgut) oder Satzart ‘H’ (Packstück-Nr.) folgen!
#    dict(kength=68, startpos=  60, endpos=123, name='frei'),
#]
# Verpackungsartschlüssel (Satzart ‘F’, Positionen 009/010, 015/016, 071/072 und 077/078)
# Schlüssel Art
# AB Auf Bohlen
# AD AD-Bahnbehälter
# BD BD-Bahnbehälter
# BE Beutel
# BL Ballen
# BU Bund
# CC Collico
# CO SystemPlus Collo
# CD CD-Bahnbehälter
# CP Chep-Palette
# DO Dose
# DR Drum
# EI Eimer
# EB Einweg-Behälter
# EP Einweg-Palette
# FA Fass
# FK Faltkiste
# FL Flasche
# FP DB Euro-Flachpalette
# GE Gebinde
# GP Gitterboxpalette
# GS Gestell
# HC Haus-Haus-Corlette
# HO Hobbock
# HP Halbpalette
# KA Kanne
# KB Kundeneigener Sonderbehälter
# KF Korbflasche
# KI Kiste
# KN Kanister
# KO Korb
# KP Kundeneigene Sonderpalette
# KS Kasten
# KT Karton
# PA Paket
# PK Pack
# RC Rollcontainer
# RG Ring
# RO Rolle
# SA Sack
# SB Spediteureigener Behälter
# ST Stück
# TC Tankcontainer
# TR Trommel
# UV Unverpackt
# VG Verschlag

# 'H':  '002%(barcode)-35s%(foo)35s%(foo)35s%(foo)16s',
# doctext = """Packstück-Nummern-Satz (je Packstück-Nr./Gruppe; mehrfach möglich)"""
#
# BARCODETYP_CHOICES = { 1: 'Freie, unformatierte Markierung',
#                        2: 'Nummer der Versandeinheit (EAN 128)',
#                        3: 'Nummer der Versandeinheit (EAN 128) FORTRAS',
#                        4: 'Paket-Nummer DPD (2/5 Interleaved)',
#                        5: 'Router Label-Nummer DPD (2/5 Interleaved)',
#                        6: 'Packstück-Nummer SystemPlus (2/5 Interleaved)',
#                        7: 'Router Label-Nummer SystemPlus (2/5 Interleaved)',
#                        8: 'IDS-Barcode (2/5 Interleaved)',
#                        9: 'IDS-Barcode (39)',
#                       10: 'IDS-Barcode (128)',
#                       11: 'Nummer der Versandeinheit (Philips)',
#                       12: 'Wechselbehälter-Barcode (2/5 Interleaved)',
#                       13: 'DPD Container-Nummer (2/5 Interleaved)',
#                       }
# Hfelder = [
#     dict(length= 3, startpos=  0, endpos=  3, name='barcodeart', fieldclass=IntegerFieldZerotagged,
#          choices=BARCODETYP_CHOICES),
#     dict(length=35, startpos=  3, endpos= 38, name='barcode1'),
#     dict(length=35, startpos= 38, endpos= 73, name='barcode2'),
#     dict(length=35, startpos= 73, endpos=108, name='barcode3'),
#     dict(length=16, startpos=108, endpos=123, name='frei'),
# ]
#
# # 'I': ('%(sendungsnummer)-16s%(sendungskilo)05d0000000000%(ladedm)03d    %(frankatur)-2s%(frankatur)-2s  %(foo)30s  %(foo)30s%(foo)16s  '),
# doctext = """Sendungs-Gewichte (je Sendung 1x)"""
#
# # Frankaturschlüssel des Spediteur-Übergabescheins (Satzart ‘I’, Positionen 043/044)
# # kann Bordero-Frankatur wie folgt ergeben:
# FRANKATUR_CHOICES = { 0: 'ohne Berechnung',
#                       4: 'Frei Empfangsspediteur',
#                       2: 'frei Haus',
#                       5: 'frei Haus verzollt',
#                       6: 'frei Haus unverzollt ',
#                       7: 'unfrei',
#                       9: 'Nachlieferung',
#                       }
#
# # Hinweistextschlüssel (Satzart ‘I’, Positionen 047/048 und 079/080 sowie Satzart ‚T‘
# # Positionen 002/003, 034/035 und 066/067)
# # * Exakte Definition der Formate bei Schlüsseln mit Zusatztext:
# #    1) Datum (TTMMJJJJ); Feldgröße: 8 Stellen
# #    2) Uhrzeit (SSMM); Feldgröße: 4 Stellen
# #    Die Positionen 049 - 056 enthalten das Datum (TTMMJJJJ), Position
# #    057 ist leer, die Positionen 058 - 051 enthalten die Uhrzeit (SSMM).
# HINWEISTEXTTYP_CHOICES = { 1: 'Sendung bitte avisieren unter Tel.-Nr.',
#                            2: 'Recall-Service - Nach Zustellung Rückruf unter Tel.-Nr.',
#                            3: 'Achtung Zollgut, Anlage Zollversandschein',
#                           14: 'Termindienst! Auslieferung spätestens am (nicht Eingangstag)',
#                           15: 'Fixtermin! Nicht früher oder später - am',
#                           16: 'Termingut! Unbedingt zustellen in KW:',
#                           17: 'SystemPlus 10-Uhr-Service - Zustellung bis 10.00 Uhr',
#                           18: 'SystemPlus 12-Uhr-Service - Zustellung bis 12.00 Uhr',
#                           19: 'SystemPlus Next-Day-Service (24 Std.-Service)',
#                           20: 'SystemPlus international Express Service',
#                           21: 'Sendung bitte nur liegend transportieren',
#                           22: 'Thermogut - vorgegebenen Temperaturbereich beachten',
#                           23: 'Empfänger kann Regalservice verlangen',
#                           25: 'Samstag-Service via Night Star Express',
#                           50: 'Warenwertnachnahme - Quick-Nachnahme',
#                           51: 'Zustellung unbedingt mit Hebebühnen-LKW',
#                           52: 'Sendung vor Zustellung telefonisch avisieren',
#                           53: 'Achtung Warenwertnachnahme - nur gegen bar ausliefern',
#                           58: 'Warenwertnachnahme - Verrechnungsscheck',
#                           60: 'Sendung ohne Entladung direkt ausliefern',
#                           61: 'Empfindliche Ware - vorsichtig behandeln',
#                           70: 'Lieferscheinnummer',
#                           71: 'Kundenauftragsnummer',
#                           72: 'Abholauftragsreferenz',
#                           73: 'Freie weitere Kundenreferenz',
#                           74: 'Retourenreferenz',
#                           }
#
#
# # Hinweistextschlüssel der Auftragsart (Satzart ‘I’, Position 127)
# # 'I': ('%(sendungsnummer)-16s%(sendungskilo)05d0000000000%(ladedm)03d    %(frankatur)-2s%(frankatur)-2s  %(foo)30s  %(foo)30s%(foo)16s  '),
# Ifelder = [
#     dict(lentgth=16, startpos=  0, endpos= 16, name='Sendungs-Nr. Versandpartner****** muss'),
#     dict(lentgth= 5, startpos= 16, endpos= 21, name='gewicht', fieldclass=IntegerField,
#          doc="Sendungsgewicht in KG"),
#     dict(lentgth= 5, startpos= 21, endpos= 26, name='gewicht_frachtpflichtig', fieldclass=IntegerField,
#          doc="Frachtpflichtiges Sendungsgewicht in KG"),
#     dict(lentgth= 5, startpos= 26, endpos= 31, name='kubikdezimeter', fieldclass=IntegerField),
#     dict(lentgth= 3, startpos=  0, endpos=123, name='lademeter', fieldclass=DecimalFieldWithoutDot,
#          precision=1),
#     dict(lentgth= 2, startpos=  0, endpos=123, name='zusaetzliche_ladehilfsmittel', fieldclass=IntegerField),
#     dict(lentgth= 2, startpos=  0, endpos=123, name='verpackungsart_zusaetzliche_ladehilfsmittel'), # 2 041 - 042
#     dict(lentgth= 2, startpos=  0, endpos=123, name='frankatur_fpediteur-Über- gabeschein* muss', choices=FRANKATUR_CHOICES), # 2 043 - 044
#     dict(lentgth= 2, startpos=  0, endpos=123, name='Frankatur Bordero* muss', choices=FRANKATUR_CHOICES), # 2 045 - 046
#     dict(lentgth= 2, startpos=  0, endpos=123, name='Hinweistextschlüssel 1** kann'), # 2 047 - 048
#     dict(lentgth=30, startpos=  0, endpos=123, name='Hinweiszusatztext 1 kann'), # 30 049 - 078
#     dict(lentgth= 2, startpos=  0, endpos=123, name='Hinweistextschlüssel 2** kann'), # 2 079 - 080
#     dict(lentgth=30, startpos=  0, endpos=123, name='Hinweiszusatztext 2 kann'), # 30 081 - 110
#     dict(lentgth=16, startpos=  0, endpos=123, name='Sendungs-Nr.  Empfangspartner*** kann'),  # 16 111 - 126
#     dict(lentgth= 1, startpos=121, endpos=122, name='auftragsart**** kann'), # 1 127 - 127
#     dict(lentgth= 1, startpos=122, endpos=123, name='lieferscheindaten_folgen', fieldclass=FixedField,
#          default=' '),
# ]
#** siehe beigefügter Hinweistextschlüssel
#*** bei Nachlieferungen (Original-Sendungs-Nr. des EP) bzw. bei Ersterfassung von über-
#zähligen Sendungen (vorläufige Sendungs-Nr. des EP)
#**** siehe beigefügter Schlüsseltabelle für Auftragsarten


# 'L': ('%(sendungen)05d%(packstuecke)05d%(bruttogewicht)05d'
#       + '%(kostensteuerplichtig)09d%(kostensteuerfrei)09d000000000%(kostenzoll)09d'
#       + '%(eust)09d000%(gitterboxen)03d%(europaletten)03d000000000000'
#       + '%(sonstigeladehilfsmittel)03d000N%(foo)36s'),
#                                                (Muss/Kann)              davon dezimal                      Position
# Bordero-Summen-Satz       muss
# (je Bordero 1x)
# Satzart ‘L’ muss 1 001 - 001
# Konstante ‘999’ muss 3/0 002 - 004
# Gesamt-Sendungs-Anzahl muss 5/0 005 - 009
# Gesamt-Packstück-Anzahl muss 5/0 010 - 014
# Tatsächliches Bruttoge-
# wicht gesamt in kg muss 5/0 015 - 019
# Gesamt-Empf.-Kosten
# steuerpflichtig muss 9/2 020 - 028
# Gesamt-Empf.-Kosten
# steuerfrei muss 9/2 029 - 037
# Gesamt-Versendernach-
# nahme muss 9/2 038 - 046
# Gesamt-Zoll muss 9/2 047 - 055
# Gesamt-EUSt muss 9/2 056 - 064
# Anzahl SB = spediteur-
# eigene Behälter muss 3/0 065 - 067
# Anzahl GP = Gitterbox-
# Paletten** muss 3/0 068 - 070
# Anzahl FP = Euro-Flach-
# Paletten** muss 3/0 071 - 073
# Anzahl CC = Collico muss 3/0 074 - 076
# Anzahl AD = Bahnbehälter muss 3/0 077 - 079
# Anzahl BD = Bahnbehälter muss 3/0 080 - 082
# Anzahl CD = Bahnbehälter muss 3/0 083 - 085
# Anzahl FP = zusätzliche
# Ladehilfsmittel ** muss 3/0 086 - 088
# Anzahl GP = zusätzliche
# Ladehilfsmittel** muss 3/0 089 - 091
# Clearing-Kennzeichen (J/N)*muss 1 092 - 092
# Frei  36 093 - 128
# Die Summenfelder für Frachtbeträge, Kosten und Nachnahmen innerhalb dieser Satzart sind
# währungsneutral, d.h. es ist lediglich eine Summierung der Werte aus der Satzart K vorzunehmen.
# Eine Währungsumrechnung darf nicht erfolgen.
# * J  = Kosten sind für das Clearing zu berücksichtigen (wird nicht verwendet)
# N = Kosten sind nicht für das Clearing zu berücksichtigen (wird nicht verwendet)
#
#
# 'T': ('%(textschluessel1)02s%(hinweistext1)-30s'
#       + '%(textschluessel2)02s%(hinweistext2)-30s'
#       + '%(textschluessel3)02s%(hinweistext3)-30s%(foo)28s'),
# Textschlüssel-Satz*                        kann
# (je Sendung maximal 3x)
# Satzart ‘T’ muss 1 001 - 001
# Laufende Bordero-Position muss 3/0 002 - 004
# Hinweistextschlüssel 1** kann 2 005 - 006
# Hinweiszusatztext 1 kann 30 007 - 036
# Hinweistextschlüssel 2** kann 2 037 - 038
# Hinweiszusatztext 2 kann 30 039 - 068
# Hinweistextschlüssel 3** kann 2 069 - 070
# Hinweiszusatztext 3 kann 30 071 - 100
# Frei
#
# 'J':  '%(zusatztext1)-62s%(zusatztext2)-62s',
# Satzart ‘J’ muss 1 001 - 001
# Laufende Bordero-Position muss 3/0 002 - 004
# Zusatztext 1 muss 62 005 - 066
# Zusatztext 2 kann 62 067 - 128

class Bordero(object):
    """Kapselt die Daten für ein Gefäß (LKW) - Verwendung ähnlich IFTSTAR."""

    def __init__(self, empfangspartner='11515'):
        super(Bordero, self).__init__()
        self.filename = ""
        self.empfangspartner = empfangspartner
        self.lieferungen = []
        self.satznummer = 0
        self.borderonr = None
        self.verladung = None
        self.generated_output = ''
        # definitions of records
        self.satzarten = {'A': (u'%(borderonr)018d%(datum)-8s%(versandweg)s  %(empfangspartner)-10s %(frachtfuehrer)'
                                + '-13s%(plz)-9s%(ort)-12s%(foo)-49s6'),
                          'B': u'%(name1)-35s%(name2)-35s%(strasse)-35s%(lkz)-3s%(plz)-9s       ',
                          'C': u'%(ort)-35s%(foo)-3s%(foo)9s%(foo)35s%(kdnnr)17s%(wert)09fEUR%(foo)-13s',
                          'D': u'%(name1)-35s%(name2)-35s%(foo)-35s%(foo)-19s',
                          'E': (u'%(strasse)-35s%(lkz)-3s%(plz)-9s%(ort)-35s%(foo)3s%(matchcode)-10s'
                                + '%(kdnnr)17s%(foo)10s%(foo)2s'),
                          'F': (u'%(anzahlpackstuecke)04d%(verpackungsart)2s0000  %(wareninhalt)-20s'
                                + '%(zeichennr)-20s%(sendungskilo)05d00000%(foo)-62s'),
                          'H': '002%(barcode)-35s%(foo)35s%(foo)35s%(foo)16s',
                          'I': (u'%(sendungsnummer)-16s%(sendungskilo)05d0000000000%(ladedm)03d    '
                                + '%(frankatur)-2s%(frankatur)-2s  %(foo)30s  %(foo)30s%(foo)16s  '),
                          'L': (u'%(sendungen)05d%(packstuecke)05d%(bruttogewicht)05d'
                                + '%(kostensteuerplichtig)09d%(kostensteuerfrei)09d000000000%(kostenzoll)09d'
                                + '%(eust)09d000%(gitterboxen)03d%(europaletten)03d000000000000'
                                + '%(sonstigeladehilfsmittel)03d000N%(foo)36s'),
                          'T': (u'%(textschluessel1)02s%(hinweistext1)-30s'
                                + '%(textschluessel2)02s%(hinweistext2)-30s'
                                + '%(textschluessel3)02s%(hinweistext3)-30s%(foo)28s'),
                          'J': u'%(zusatztext1)-62s%(zusatztext2)-62s',
                          }

    def add_lieferung(self, lieferung):
        """Adds a lieferung to our Bordero."""
        if self.generated_output:
            raise RuntimeError('tried to  add data to an already exported Bordero.')
        self.lieferungen.append(lieferung)

    def generate_satz(self, satzart, data):
        """Helper function to generate output for a Record."""
        for key in data.keys():
            if isinstance(data[key], str):
                data[key] = unicode(data[key], 'ascii', errors='ignore')
        ret = ((u'%s%03d' % (satzart, self.satznummer)) +
               (self.satzarten[satzart] % data))
        if len(ret) != 128:
            raise RuntimeError('bordero Satz %r kaputt! (len=%r) %r %r' % (satzart, len(ret), ret, data))
        return ret

    def generate_kopfsatz_a(self, verladung=None):
        """Generates bodero record A - header."""
        # Bordro nummer - Fortlaufend?
        # Verkehrsart - immer LKW?
        # IDNr des Verrsandpartyners beim Empfangspartern? L515
        # Frachtführername - Mäuler?
        # Ladeeinheitnr - 1 & 2? frei
        # Plombennummer ?        frei
        if not self.borderonr:
            raise RuntimeError('No bordero nr set.')
        data = {'empfangspartner': self.empfangspartner, 'frachtfuehrer': 'Maeuler', 'plz': '42897',
                'ort': 'Remscheid', 'versandweg': 'L', 'foo': '',
                'datum': time.strftime('%d%m%Y'),
                'borderonr': self.borderonr}
        if verladung:
            if verladung.spedition == 'Direktfahrt':
                data['versandweg'] = 'X'
        return self.generate_satz('A', data)

    def generate_versendersatz_b(self, lieferung):
        """Generates bodero record B - first half of sender."""
        data = {'name1': 'HUDORA GmbH', 'name2': '', 'strasse': u'Jägerwald 13', 'lkz': 'DE',
                'plz': '42897'}
        return self.generate_satz('B', data)

    def generate_versendersatz_c(self, lieferung):
        """Generates bodero record C - second half of sender."""
        data = {'ort': 'Remscheid', 'foo': ' ', 'kdnnr': self.empfangspartner, 'wert': 0}
        return self.generate_satz('C', data)

    def generate_empfaengersatz_d(self, lieferung):
        """Generates bodero record D - first half of recipient."""
        data = {'name1': _clip(35, lieferung.name1), 'name2': _clip(35, lieferung.name2), 'foo': ' '}
        return self.generate_satz('D', data)

    def generate_empfaengersatz_e(self, lieferung):
        """Generates bodero record E - second half of recipient."""
        data = {'strasse': _clip(35, lieferung.adresse), 'lkz': _clip(3, lieferung.land),
        'plz': _clip(9, lieferung.plz), 'ort': _clip(35, lieferung.ort), 'kdnnr': lieferung.kundennummer,
        'matchcode': _clip(10, (lieferung.name1 + lieferung.ort).replace(' ', '')), 'foo': ' '}
        return self.generate_satz('E', data)

    def generate_sendungspossatz_f(self, lieferung):
        """Generates bodero record F."""
        # Packstück Anzahl? Pakete? Paletten? NVEs!
        # Fuer weitere Paletten typen neuen Satz
        # Tatsächliches Gewicht einpflegen
        data = {'anzahlpackstuecke': len(lieferung.packstuecke),
        'verpackungsart': _clip(2, 'FP'),
        'sendungskilo': int(lieferung.gewicht / 1000),
        'wareninhalt': _clip(20, 'HUDORA Sportartikel'),
        'zeichennr': _clip(20, '%s/%s' % (lieferung.lieferscheinnummer, lieferung.id)),
        'foo': ''}
        return self.generate_satz('F', data)

    def generate_packstuecksatz(self, lieferung, packstueck):
        """Generates bodero record H."""
        barcode = packstueck.nve
        if not barcode.startswith('00'):
            barcode = '00' + barcode
        data = {'barcode': barcode,
        'foo': ' '}
        return self.generate_satz('H', data)

    def generate_sendungsinfosatz_i(self, lieferung):
        """Generates bodero record I."""
        # Sendungsnummer - eindeutig!
        data = {'sendungsnummer': _clip(16, "%016s" % lieferung.id),
        'ladedm': 0,
        'frankatur': '02',  # frei Haus
        'foo': ' '}
        data['sendungskilo'] = int(lieferung.gewicht / 1000)
        return self.generate_satz('I', data)

    def generate_textsatz_t(self, lieferung, schluesselliste):
        """Generates bodero record(s) T - text info."""
        satz = []
        ret = []
        for schluessel, text in schluesselliste:
            satz.append((schluessel, text))
            if len(satz) == 3:
                data = {'textschluessel1': '%02d' % int(satz[0][0]), 'hinweistext1': _clip(30, satz[0][1]),
                        'textschluessel2': '%02d' % int(satz[1][0]), 'hinweistext2': _clip(30, satz[1][1]),
                        'textschluessel3': '%02d' % int(satz[2][0]), 'hinweistext3': _clip(30, satz[2][1]),
                        'foo': ' '}
                satz = []
                ret.append(self.generate_satz('T', data))
        if len(satz) > 0:
            data = {'textschluessel1': '%02s' % int(satz[0][0]), 'hinweistext1': _clip(30, satz[0][1]),
                    'textschluessel2': '  ', 'hinweistext2': '',
                    'textschluessel3': '  ', 'hinweistext3': '',
                    'foo': ' '}
            if len(satz) > 1:
                data['textschluessel2'] = '%02d' % int(satz[1][0])
                data['hinweistext2'] = _clip(30, satz[1][1])
            ret.append(self.generate_satz('T', data))
        return '\n'.join(ret)

    def generate_textsaetze(self, lieferung):
        """Generate as many T records as needed."""
        schluesselliste = []
        if lieferung.avisieren_unter:
            # 52 = Sendung vor Zustellung telefonisch avisieren
            # 01 = Sendung bitte avisieren unter Tel.-Nr.: ...(Zusatztext)
            schluesselliste.append(('01', _clip(30, lieferung.avisieren_unter)))
        if lieferung.fixtermin:
            # 15 = Fixtermin! Nicht früher oder später - am: ... (Zusatztext)*
            datum = lieferung.fixtermin.strftime('%d%m%Y')
            zeit = lieferung.fixtermin.strftime('%H:%M')
            if zeit == '00:00':
                zeit = '     '
            timestamp = '%8s %5s' % (datum, zeit)
            schluesselliste.append(('15', _clip(30, timestamp)))
        if lieferung.hebebuehne:
            # 51 = Zustellung unbedingt mit Hebebühnen-LKW
            schluesselliste.append(('51', _clip(30, 'Zustellung mit Hebebühne')))
        if lieferung.auftragsnummer_kunde.strip():
            # 71 = Kundenauftragsnummer (Nummer im Zusatztext)
            schluesselliste.append(('71', _clip(30, lieferung.auftragsnummer_kunde)))
        # 70 = Lieferscheinnummer (Nummer im Zusatztext)
        schluesselliste.append(('70', _clip(30, lieferung.lieferscheinnummer)))
        # 73 = Freie weitere Kundenreferenz (Referenz im Zusatztext)
        # schluesselliste.append(('73', _clip(30, 'http://hudora.de/track/XXX')))

        # 14 = Termindienst! Auslieferung spätestens am (nicht Eingangstag): (Zusatztext)*
        # 16 = Termingut! Unbedingt zustellen in KW: ... (Zusatztext)
        # 61 = Empfindliche Ware - vorsichtig behandeln
        return self.generate_textsatz_t(lieferung, schluesselliste)

    def generate_zusatztextsatz_j(self, lieferung):
        """Generates bodero record J - additional text info."""
        data = {'zusatztext1': _clip(62, u'AuftragsNr: %s / KundenNr: %s' %
                                         (lieferung.auftragsnummer, lieferung.kundennummer)),
                'zusatztext2': _clip(62, u'huLOG Code: %s' % lieferung.code),
                'foo': ' '}
        return self.generate_satz('J', data)

    def generate_summensatz_l(self):
        """Generates bodero record L."""
        # Was ist ein Packstück? => NVEs
        # Empfangskosten?
        # Was bei Einwegpaletten?
        # Was bei CHEP / Düsseldorfer Paletten = speditereigenebehaelter
        # clearing kennzeichen?
        data = {'sendungen': len(self.lieferungen),
            'bruttogewicht': int(sum([lieferung.gewicht for lieferung in self.lieferungen]) / 1000),
            'kostensteuerplichtig': 0,
            'kostensteuerfrei': 0,
            'kostenzoll': 0,
            'eust': 0,
            'gitterboxen': 0,
            'europaletten': sum([len(lieferung.packstuecke) for lieferung in self.lieferungen]),
            'packstuecke': sum([len(lieferung.packstuecke) for lieferung in self.lieferungen]),
            'sonstigeladehilfsmittel': 0,
            'foo': '',
        }
        self.satznummer = 999
        return self.generate_satz('L', data)

    def generate_lieferungssaetze(self, lieferung):
        """Generates all bodero records for a shipment."""
        self.satznummer += 1
        out = []
        out.append(self.generate_versendersatz_b(lieferung))
        out.append(self.generate_versendersatz_c(lieferung))
        out.append(self.generate_empfaengersatz_d(lieferung))
        out.append(self.generate_empfaengersatz_e(lieferung))
        out.append(self.generate_sendungspossatz_f(lieferung))
        for packstueck in lieferung.packstuecke:
            out.append(self.generate_packstuecksatz(lieferung, packstueck))
        out.append(self.generate_sendungsinfosatz_i(lieferung))
        out.append(self.generate_textsaetze(lieferung))
        out.append(self.generate_zusatztextsatz_j(lieferung))
        return u'\n'.join(out)

    def generate_dataexport(self):
        """Return complete BODERO data."""
        if not self.generated_output:
            out = []
            out.append(self.generate_kopfsatz_a(self.verladung))
            for lieferung in self.lieferungen:
                out.append(self.generate_lieferungssaetze(lieferung))
            out.append(self.generate_summensatz_l())
            self.generated_output = (u"@@PHBORD128 0128003500107 HUDORA1 MAEULER\n"
                                     + u'\n'.join(out) + u'\n@@PT\n')
        return self.generated_output


def ship(verladung, empfangspartner='11515', basedir='/usr/local/maeuler/current/In/BORD/'):
    """Creates a BORDERO object and writes it to a file.

    The file lies in directory basedir containing the borderonr and a timestamp in its name.
    Returns the BORDERO object w/ its filename attached.
    """
    bordero = Bordero(empfangspartner)
    bordero.verladung = verladung
    bordero.borderonr = verladung.borderonr
    for lieferung in verladung.lieferungen:
        bordero.add_lieferung(lieferung)
    data = bordero.generate_dataexport()  # generate first to assure bordero.borderonr is set
    # we first create a temporary file and later rename it to it's final name
    basefilename = time.strftime('%Y%m%dT%H%M%S') + ('_%05d.txt' % (bordero.borderonr))
    tmpfilename = os.path.join(basedir, '._' + basefilename + '_tmp')
    filename = os.path.join(basedir, basefilename)
    outfile = open(tmpfilename, 'w')
    outfile.write(data.encode('latin-1', 'ignore'))
    outfile.close()
    os.rename(tmpfilename, filename)
    for lieferung in verladung.lieferungen:
        lieferung.ship()
        lieferung.log(code=201, message="Verladung abgeschlossen / DFü an Spedition (Mäuler)")
        lieferung.save()
    verladung.ship()
    bordero.filename = filename
    return bordero


def ship_lieferungen(lieferungen, empfangspartner='11515'):
    """Should be called when 'lieferungen' just left the building."""
    bordero = Bordero(empfangspartner)
    for lieferung in lieferungen:
        bordero.add_lieferung(lieferung)
    data = bordero.generate_dataexport()  # generate first to assure bordero.borderonr is set
    # we first create a temporary file and later rename it to it's finaal name
    filename = time.strftime('%Y%m%dT%H%M%S') + ('_%05d.txt' % (bordero.borderonr))
    outfile = open(os.path.join('/usr/local/maeuler/current/In/BORD/', '._' + filename + '_tmp'), 'w')
    outfile.write(data)
    outfile.close()
    os.rename(os.path.join('/usr/local/maeuler/current/In/BORD/', '._' + filename + '_tmp'),
              os.path.join('/usr/local/maeuler/current/In/BORD/', filename))
    for lieferung in lieferungen:
        lieferung.ship()
        lieferung.log(code=201, message="DFü an Mäuler")
        lieferung.save()
    return bordero


================================================
FILE: pyshipping/fortras/entl.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
entl.py - parse Fortras ENTL messages.

Created by Maximillian Dornseif on 2006-11-19.
You may consider this BSD licensed.
"""

import re
import logging
import datetime


class Entladebericht(object):
    """Parses and represent an ENTL message."""
    m_record_re = (r'M(?P<borderonr>[0-9 ]{18})(?P<borderodatum>[0-9 ]{8})(?P<kundennummer>.{10})'
                   + r'(?P<eingangsdatum>[0-9 ]{8})(?P<eingangszeit>[0-9 ]{4})(?P<zeitschranfenstatus>..)'
                   + r'(?P<entladebeginn_datum>[0-9 ]{8})(?P<entladebeginn_zeit>[0-9 ]{4})'
                   + r'(?P<entladeende_datum>[0-9 ]{8})(?P<entladeende_zeit>[0-9 ]{4})'
                   + r'(?P<entladehinweis>.{30})             (?P<foo>.{9})5')
    m_record_re = re.compile(m_record_re)
    # Satzart ‘M’ muss 1 001 - 001
    # Bordero-Nr.Versandpartner muss          18 002 - 019
    # Borderodatum Versandpartner (TTMMJJJJ) muss 8/0 020 - 027
    # Kunden-Nr. Empfangspartner beim Versandpartner muss          10 028 - 037
    # Eingangsdatum (TTMMJJJJ) muss 8/0 038 - 045
    # Eingangszeit (SSMM) muss 4/0 046 - 049
    # Zeitschranken-Status* muss 2 050 - 051
    # Entladebeginn-Datum (TTMMJJJJ) muss 8/0 052 - 059
    # Entladebeginn Zeit (SSMM) muss 4/0 060 - 063
    # Entladeende-Datum (TTMMJJJJ) muss 8/0 064 - 071
    # Entladeende-Zeit (SSMM) muss 4/0 072 - 075
    # Nicht sendungsbezogener Entladehinweis-Text kann          30 076 - 105
    # Euro-Paletten-Belastung  Versandpartner aus Bordero kann 3/0 106 - 108
    # Gitterbox-Paletten-  Belastung Versandpartner  aus Bordero kann 3/0 109 - 111
    # Euro-Paletten-Entladung Empfangspartner kann 3/0 112 - 114
    # Gitterbox-Paletten-Entladung Empfangspartner kann 3/0 115 - 117
    # Verkehrsart** kann 1 118 - 118
    # Frei 9 119 - 127
    # Releasestand 
5’ muss 1 128 - 128

    n_record_re = (r'N(?P<borderonr>[0-9 ]{18})(?P<position>[0-9 ]{3})(?P<sendungsnrversender>[0-9 ]{16})'
                   + r'(?P<sendungsnrempfaenger>[0-9 ]{16})(?P<differenzschluessel1>..)'
                   + r'(?P<differenzzahl1>[0-9 ]{4})(?P<verpackungsart1>..)(?P<differenztext1>.{29})'
                   + r'(?P<differenzschluessel2>..)(?P<differenzzahl2>[0-9 ]{4})(?P<verpackungsart2>..)'
                   + r'(?P<differenztext2>.{29})')
    n_record_re = re.compile(n_record_re)
    # Satzart ‘N’ muss 1 001 - 001
    # Bordero-Nr. Versandpartner muss          18 002 - 019
    # Laufende Bordero-Position Versandpartner muss 3/0 020 - 022
    # Sendungs-Nr.  Versandpartner muss          16 023 - 038
    # Sendungs-Nr. Empfangspartner muss          16 039 - 054
    # Differenzartschlussel 1* muss 2 055 - 056
    # Differenzanzahl 1 kann 4/0 057 - 060
    # Verpackungsart 1** kann 2 061 - 062
    # Text/Hinweis 1 kann          29 063 - 091
    # Differenzartschlussel 2* kann 2 092 - 093
    # Differenzanzahl 2 kann 4/0 094 - 097
    # Verpackungsart 2** kann 2 098 - 099
    # Text/Hinweis 2 kann          29 100 - 128

    # no match 'V461               720-00             00340498430009431112               0                          19092008183100              '
    v_record_re = (r'V(?P<borderonr>[0-9 ]{18})(?P<sendungsnrversender>.{16})(?P<barcodetype>...)'
                   + r'(?P<nve>.{35})(?P<hinweiscode>...)(?P<hinweistext>.{24})'
                   + r'(?P<date>[0-9 ]{8})(?P<time>[0-9 ]{4})'
                   + r'(?P<benutzer>.{10})(?P<terminal>.{4})')
    v_record_re = re.compile(v_record_re)
    # Lost 'N'-Satz ab bei Einsatz von Barcode
    # Satzart ‘V’ muss 1 001 - 001
    # Bordero-Nr. Versandpartner muss          18 002 - 019
    # Sendungs-Nr. Versandpartner muss          16 020 - 035
    # Barcode-Qualifier * kann 3 036 - 038
    # Barcode-Nr. muss          35 039 - 073
    # Fehler-/Hinweiscode 1 ** muss 3 074 - 076
    # Frei wahlbarer Text/Hinweis kann          24 077 - 100
    # Ereignisdatum (TTMMJJJJ) muss 8 101 - 108
    # Ereignisuhrzeit (HHMMSS) muss 6 109 - 114
    # Benutzer-ID kann          10 115 - 124
    # Scanner/Terminal-ID kann 4 125 - 128
    # Fehler-/Hinweiscode:
    statustexte = {
        0: 'Packstck',
        2: 'Packstck eingedrckt',
        3: 'Packstck aufgerissen, Ware greifbar',
        4: 'Packstck nass',
        5: 'Packstckinhalt luft aus',
        9: 'Packstck beschdigt',
       10: 'Euro-Palette',
       11: 'Euro-Palette, Ware beschdigt',
       12: 'Euro-Palette beschdigt',
       13: 'Euro-Palette und Ware beschdigt',
       14: 'Euro-Palette verschweit/gewickelt',
       15: 'Euro-Palette, Folie ein-/aufgerissen, Ware greifbar',
       19: 'Euro-Palette und/oder Ware mit Beschdigung',
       20: 'Gitterbox',
       21: 'Gitterbox, Ware beschdigt',
       22: 'Gitterbox beschdigt',
       23: 'Gitterbox und Ware beschdigt',
       29: 'Gitterbox und/oder Ware mit Beschdigung',
       30: 'Halbpalette',
       31: 'Halbpalette, Ware beschdigt',
       32: 'Halbpalette beschdigt',
       33: 'Halbpalette und Ware beschdigt',
       34: 'Halbpalette verschweit/gewickelt',
       35: 'Halbpalette, Folie ein-/aufgerissen, Ware greifbar',
       39: 'Halbpalette und/oder Ware mit Beschdigung',
       40: 'Einwegpalette',
       41: 'Einwegpalette, Ware beschdigt',
       42: 'Einwegpalette beschdigt',
       43: 'Einwegpalette und Ware beschdigt',
       44: 'Einwegpalette verschweit/gewickelt',
       45: 'Einwegpalette, Folie ein-/aufgerissen, Ware greifbar',
       49: 'Einwegpalette und/oder Ware mit Beschdigung.',
       50: 'Packstck fehlt bei Entladung',  # (Wird durch Entladebericht beim EP erzeugt)
       51: 'Backbox SK1*',
       52: 'Backbox SK2*',
       53: 'Backbox SK3*',
       54: 'Backbox SK4*',
       62: 'HUB/Konsolidierungspunkt - Packstck handverteilt',
       63: 'HUB/Konsolidierungspunkt - Palette mit berma',
       64: 'HUB/Konsolidierungspunkt - Packstuckroutung nicht lesbar (Nachbearbeitung)',
       65: 'HUB/Konsolidierungspunkt - Versender Direktanlieferung - Aufkleber erstellt',
       66: 'HUB/Konsolidierungspunkt - Dienstleistung - Routung durch HUB / Konsolidierungspunkt',
       67: 'HUB/Konsolidierungspunkt - Dienstleistung - Vereinbarte Nachbearbeitung',
       68: 'HUB/Konsolidierungspunkt - Retoure HUB / Konsolidierungspunkt an Versandspediteur',
       69: 'HUB/Konsolidierungspunkt - Ware im HUB / Konsolidierungspunkt stehen geblieben',
       70: 'HUB/Konsolidierungspunkt - Ware im HUB palettiert',
       93: 'Routerfehler',
       94: 'Verladefehler',
       95: 'PLZ-Fehler*',
       96: 'Platzmangel',
       97: 'Zeitmangel',
       98: 'Rckscannung - Packstuck wieder entladen',
       99: 'Korrekturscannung',
       }

    def update_packstueck(self, nve, datadict):
        """Updates a huLOG Packstueck record with the parsed ENTL data."""

        # TODO: decouple this from huLOG
        import huLOG.models
        try:
            packstueck = huLOG.models.Packstueck.objects.get(_trackingnummer=nve)
        except huLOG.models.Packstueck.DoesNotExist:
            logging.warning('Problem locating Packstueck with barcode %r for ENTL record - ignoring' % nve)
            return
        info = []
        if datadict['terminal']:
            info.append('an Terminal %r' % datadict['terminal'])
        if datadict['benutzer']:
            info.append('gescannt durch Nutzer %r' % datadict['benutzer'])
        if datadict['hinweiscode'] in ['0', '']:
            info.insert(0, 'Bei der Spedition entladen')
            if datadict['hinweistext']:
                info.insert(1, datadict['hinweistext'])
            if datadict['timestamp']:
                info.append(str(datadict['timestamp']))
            log = huLOG.models.PackstueckLogentry(packstueck=packstueck)
            log.displaytext = ', '.join(info)
            log.sourcedata = repr(datadict)
            log.source = 'Maeuler ENTL'
            log.code = '200'
            log.timestamp = datadict['timestamp']
            log.save()
        elif datadict['hinweiscode'] in ['50']:
            info.insert(0, 'Fehlte bei der Entladung')
            log = huLOG.models.PackstueckLogentry(packstueck=packstueck)
            log.displaytext = ', '.join(info)
            log.sourcedata = repr(datadict)
            log.source = 'Maeuler ENTL'
            log.code = '500'
            log.timestamp = datadict['timestamp']
            log.save()
        else:
            logging.error('unknown ENTL data: %r (%r)' % (datadict['hinweiscode'],
                                                          datadict['hinweistext']))

    def parse(self, data):
        """Parses Fortras ENTL data."""
        lines = data.split('\n')
        if not lines[0].startswith('@@PHENTL128 0128003500107 MAEULER HUDORA1                       '):
            raise RuntimeError("illegal status data %r" % data[:300])
        for line in lines[1:]:
            line = line.strip('\r')
            if not line:
                continue
            if line[0] == 'M':
                match = re.search(Entladebericht.m_record_re, line)
                if not match:
                    print 'no match', repr(line)
                # the content of M records are ignored
            elif line[0] == 'N':
                match = re.search(Entladebericht.n_record_re, line)
                if not match:
                    print 'no match', repr(line)
                # the content of N records are ignored
            elif line[0] == 'V':
                match = re.search(Entladebericht.v_record_re, line)
                newdict = {}
                if not match:
                    print 'no match', repr(line)
                for key, value in match.groupdict().items():
                    newdict[key] = value.strip()
                newdict['timestamp'] = datetime.datetime(int(newdict['date'][4:]), int(newdict['date'][2:4]),
                                                         int(newdict['date'][:2]), int(newdict['time'][:2]),
                                                         int(newdict['time'][2:]))
                newdict['sendungsnrversender'] = newdict['sendungsnrversender']
                self.update_packstueck(newdict['nve'], newdict)

            elif line[0] == 'W':
                pass  # we happyly ignore W records
            else:
                print "unknown %r" % line


================================================
FILE: pyshipping/fortras/fakt.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
fakt.py

Created by Christian Klein on 2011-03-31.
Copyright (c) 2011 HUDORA GmbH. All rights reserved.
"""

import csv
import datetime
import decimal
import StringIO


FIELDNAME_MAPPING = {
    'Firma': 'firma',
    'T-Datum': 'datum',
    'Frachtbrief': 'frachtbrief',
    'Versender-Ref.': 'lieferung_id',
    'Abs.-Name': 'absender_name1',
    'Abs.-Str.': 'absender_strasse',
    'Abs.-Land': 'absender_land',
    'Abs.-Plz': 'absender_plz',
    'Abs.-Ort': 'absender_ort',
    'Emp.-Name': 'empfaenger_name1',
    'Emp.-Str.': 'empfaenger_strasse',
    'Emp.-Land': 'empfaenger_land',
    'Emp.-Plz': 'empfaenger_plz',
    'Emp.-Ort': 'empfaenger_ort',
    'Zeichen+Nr.': 'zeichennr',
    'Inhalt': 'inhalt',
    'T-Gewicht': 'transportgewicht',
    'F-Gewicht': 'frachtpflgewicht',
    'KM': 'kilometer',
    'VPE': 'einheiten',
    'EURO': 'euro',
    'GIBO': 'gibo',
    'Fracht': 'fracht',
    'Maut': 'maut',
    'Summe': 'summe'}


def convert_to_decimal(value, factor=None):
    """Convert a pseudo decimal value to Decimal"""

    value = decimal.Decimal(value.replace(',', '.'))
    if factor:
        value *= factor
    return value


def convert_record(record):
    """Convert fields in record to Python data types"""

    if 'datum' in record:
        record['datum'] = datetime.datetime.strptime(record['datum'], '%d.%m.%Y')

    if 'kilometer' in record:
        record['kilometer'] = convert_to_decimal(record['kilometer'])

    for key in 'fracht', 'frachteinheiten', 'maut', 'kosten':
        if key in record:
            record[key] = convert_to_decimal(record[key], factor=100)

    for key in 'transportgewicht', 'frachtpflgewicht':
        if key in record:
            record[key] = convert_to_decimal(record[key], factor=1000)

    if None in record:
        del record[None]

    return record


def parse_fakt(data):
    """Parse BORDERO FAKT data"""

    if isinstance(data, basestring):
        data = StringIO.StringIO(data)

    header = data.readline()
    if not header.strip() == '@@PHFAKT128 FROMAT:CSV DELIMITER:;':
        raise ValueError('Unknown header: %r' % header)

    reader = csv.DictReader(data, delimiter=';')
    fieldnames = reader.fieldnames
    for index, field in enumerate(fieldnames):
        if field in FIELDNAME_MAPPING:
            del fieldnames[index]
            fieldnames.insert(index, FIELDNAME_MAPPING[field])
    reader.fieldnames = fieldnames

    # rows = dict((row['zeichennr'], convert_record(row)) for row in reader)
    rows = [convert_record(row) for row in reader]
    return rows


if __name__ == "__main__":
    import sys
    import pprint
    pprint.pprint(parse_fakt(open(sys.argv[1]).read()))


================================================
FILE: pyshipping/fortras/fortras_stat.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
stat.py - parse Fortras STAT messages.

Created by Maximillian Dornseif on 2006-11-19.
You may consider this BSD licensed.
"""

import re
import datetime
import logging


class Statusmeldung(object):
    """Parses and represents an STAT message."""
    q_record_re = (r'Q(?P<idbeimempfangspartner>.{10})(?P<verkehrsart>.)(?P<sendungsnrversender>.{16})'
                   + r'(?P<sendungsnrempfaenger>.{16})(?P<sendungsschluessel>[0-9 ]{3})(?P<date>[0-9 ]{8})'
                   + r'(?P<time>[0-9 ]{4})(?P<wartezeit>[0-9 ]{3})(?P<quittungsgeber>.{15})(?P<zusatztext>.{49})'
                   + r'(?P<foo>.)5')
    # Satzart ‘Q’ muss 1 001 - 001
    # Identifkations-Nr. des Versandpartners beim Empfangspartner** muss          10 002 - 011
    # Verkehrsart muss 1 012 - 012
    # Sendungs-Nr. Versandpartner muss          16 013 - 028
    # Sendungs-Nr.Empfangspartner muss          16 029 - 044
    # Statusschlüssel* muss 3 045 - 047
    # Datum des Ereignisses
    # (TTMMJJJJ) muss 8/0 048 - 055
    # Uhrzeit des Ereignisses
    # (SSMM) muss 4/0 056 - 059
    # Warte-/Standzeit in Minuten kann 3 060 - 062
    # Name des Quittungsgebers kann          15 063 - 077
    # Zusatztext kann          49 078 - 126
    # Frei 1 127 - 127
    # Releasestand ‘5’ muss 1 128 - 128

    # stati, die dazu fuehren, dass eine  sendung erledigt ist
    erledigtstati = [11,  # Nicht in Zustellung - Sendung endgültig in Verlust
                     12,  # Zugestellt - reine Quittung
                     66,  # Keine Zustellung - Komplett-Fehlmenge per Entladebericht gemeldet
                     67,  # Nicht zugestellt - annahmeverweigerte Sendung, Retour lt. Verfügung
                     68,  # Nicht zugestellt - annahmeverweigerte Sendung, Retour-Verfügung fehlt
                     69,  # Zugestellt - mit Teilfehlmenge
                     70,  # Zugestellt - mit Beschädigung
                     71,  # Zugestellt - Zustellung nicht belegbar/SPÜS verloren
                     74,  # Zugestellt - Teil-AV
                     80,  # AV - Ware beschädigt
                     81,  # AV - Fehlmenge
                     82,  # AV - Liefertermin überschritten
                     83,  # AV - Lieferschein fehlt/Begleitpapiere unvollständig
                     84,  # AV - Empfänger zahlt WWNN/EUSt. nicht
                     85,  # AV - nicht bestellt
                     88,  # Erledigung durch ...
                   ]
    okstati = [12, 50]
    bouncestati = [80, 81, 82, 83, 84, 85]
    errorstati = [66, 67, 68, 69, 70, 71, 74] + bouncestati
    warnstati = [5, 8, 9, 18, 63, 64, 65, 66, 99, 100] + bouncestati
    statustexte = {
         1: 'Nicht in Zustellung - Sendung fehlt komplett lt. EB',
         2: 'Nicht in Zustellung - unvollständige/falsche Sendungsangaben',
         3: 'Nicht in Zustellung – Ware beschädigt',
         4: 'Nicht in Zustellung - Sendung verstapelt/nicht auffindbar',
         5: 'Nicht in Zustellung - Platzmangel auf Zustelltour',
         6: 'Nicht in Zustellung - Fix- oder Zustelltermin lt. Vorgabe',
         7: 'Nicht in Zustellung - Empfänger außerhalb des Produktionsgebietes (24 h)',
         8: 'Nicht zugestellt - Zeitmangel auf Zustelltour',
         9: 'Nicht zugestellt - Empfänger nicht angetroffen.  Zustellbescheid hinterlassen',
        10: 'Nicht zugestellt - annahmeverweigert/unzustellbar  oder Adressfehler',
        11: 'Nicht in Zustellung - Sendung endgültig in Verlust (Protokoll folgt)',
        12: 'Zugestellt - reine Quittung',
        13: 'Nicht in Zustellung - Sendung unvollständig',
        14: 'Nicht in Zustellung - Empfänger ist Selbstabholer',
        15: 'Nicht in Zustellung – Regionaler Feiertag',
        16: 'Nicht in Zustellung - Zollgut',
        17: 'Nicht in Zustellung - Avisvorschrift lt. Beleg/Anweisung/Inkasso',
        18: 'Nicht zugestellt - zu lange Wartezeit beim Empfünger',
        22: 'Nicht in Zustellung - Lieferschein fehlt/Begleitpapiere  unvollstündig',
        31: 'Nicht in Zustellung - Fernverkehr vom VP/HUB  verspätet (E2-Status)',
        40: 'Sendung auf dem Weg zum Empfänger / in Zustellung',
        50: 'Zugestellt - reine Quittung',
        52: 'Sendung zu spät beim Empfangsspediteur angekommen, Auslieferung verspätet sich',
        53: 'Sendung für Zustellung vorgesehen / Nachladesdg',
        54: 'Sendung auf dem Weg zum Empfänger / in Zustellung',
        55: 'Nicht in Zustellung - keine Warenannahme oder Vereinbarung',
        63: 'Nicht zugestellt - keine Warennahme oder Warenannahme geschlossen',
        64: 'Nicht zugestellt - Hebebühne erforderlich',
        65: 'Nicht zugestellt - Empfänger wünscht Avis oder Fixtermin',
        66: 'Keine Zustellung - Komplett-Fehlmenge per Entladebericht gemeldet',
        67: 'Nicht zugestellt - annahmeverweigerte Sendung, Retour lt. Verfügung',
        68: 'Nicht zugestellt - annahmeverweigerte Sendung, Retour-Verfügung fehlt',
        69: 'Zugestellt - mit Teilfehlmenge',
        70: 'Zugestellt - mit Beschädigung',
        71: 'Zugestellt - Zustellung nicht belegbar/SPÜS verloren',
        74: 'Zugestellt - Teil-AV',
        80: 'AV - Ware beschädigt',
        81: 'AV - Fehlmenge',
        82: 'AV - Liefertermin überschritten',
        83: 'AV - Lieferschein fehlt/Begleitpapiere unvollständig',
        84: 'AV - Empfänger zahlt WWNN/EUSt. nicht',
        85: 'AV - nicht bestellt',
        88: 'Erledigung durch ...',
        90: 'Übermittlung des Quittungsgebers, des Zustelldatums und der Ablieferzeit',
        91: 'Zustellbeleg archiviert',
        99: 'Nicht in Zustellung - Ereignis zu Lasten Empfangspartner',
        100: 'Nicht in Zustellung - Ereignis nicht zu Lasten Empfangspartner',
    }

    def update_sendung(self, sendung_id, datadict):
        """Updates a huLOG Sendung record with the parsed STAT data."""
        import huLOG.models
        try:
            sendung = huLOG.models.Sendung.objects.get(id=sendung_id)
        except huLOG.models.Sendung.DoesNotExist:
            logging.warning('Problem locating Sendung with id %r for STAT record - ignoring' % sendung_id)
            return
        if datadict['timestamp'] > datetime.datetime.now():
            logging.warning('Future timestamp for Sendung with id %r: %s' % (sendung_id, datadict['timestamp']))
            return
        if datadict['timestamp'] < sendung.created_at:
            logging.warning('Inconsistent timestamps for Sendung with id %r: %s' % (sendung_id, datadict['timestamp']))
            return
        if int(datadict['sendungsschluessel']) in Statusmeldung.warnstati:
            sendung.needs_attention = True
        if int(datadict['sendungsschluessel']) in Statusmeldung.erledigtstati:
            sendung.delivered_at = datadict['timestamp']
            sendung.status = 'delivered'
        if int(datadict['sendungsschluessel']) in Statusmeldung.errorstati:
            sendung.needs_attention = True
            sendung.status = 'error'
        if int(datadict['sendungsschluessel']) in Statusmeldung.bouncestati:
            sendung.status = 'bounced'
            logging.warning('bounced shipment %r: %r (%r|%r)' % (datadict['sendungsnrversender'],
                                                                       datadict['sendungsschluessel'],
                                                                       datadict['statustext'],
                                                                       datadict['zusatztext']))

        if datadict['statustext']:
            info = [datadict['statustext']]
        else:
            info = ['']
        if datadict['quittungsgeber']:
            info.append('quittiert durch %r' % datadict['quittungsgeber'])
        if datadict['wartezeit']:
            info.append('Wartezeit % min' % int(datadict['wartezeit']))
        if datadict['zusatztext']:
            info.append(datadict['zusatztext'])
        info.append(str(datadict['timestamp']))
        log = huLOG.models.SendungLogentry(lieferung=sendung)
        log.displaytext = repr(', '.join(info))
        log.sourcedata = repr(datadict)
        log.source = 'Maeuler STAT'
        log.code = '200'
        if datadict['sendungsschluessel'] in Statusmeldung.warnstati:
            log.code = '220'
        if datadict['sendungsschluessel'] in Statusmeldung.errorstati:
            log.code = '230'
        log.timestamp = datadict['timestamp']
        log.save()
        sendung.updated_at = datetime.datetime.now()

        # we only save well known stati
        if datadict['sendungsschluessel'] in ['005', '006', '007', '008', '009', '012', '015', '016', '017',
                                              '018', '031', '040', '050', '054', '055', '063', '068', '069',
                                              '071', '084', '085', '091', '099', '053', '100', '999']:
            if datadict['sendungsnrempfaenger']:
                if (sendung.speditionsauftragsnummer
                  and sendung.speditionsauftragsnummer != datadict['sendungsnrempfaenger']):
                    logging.error('Problem with Sendung %r: original speditionsauftragsnummer %r replaced by %r' % (sendung, sendung.speditionsauftragsnummer, datadict['sendungsnrempfaenger']))
                sendung.speditionsauftragsnummer = datadict['sendungsnrempfaenger']
        else:
            logging.error('unknown STAT data for record %r: %r (%r|%r)' % (datadict['sendungsnrversender'],
                                                                           datadict['sendungsschluessel'],
                                                                           datadict['statustext'],
                                                                           datadict['zusatztext']))
        sendung.save()

    def parse(self, data):
        """Parses Fortras STAT data."""
        lines = data.split('\n')
        lines = [x.strip('\r') for x in lines]
        if lines[0] == '' and len(lines) == 1:
            logging.error('empty file')
            return
        if not lines[0].startswith('@@PHSTAT128 0128003500107 MAEULER HUDORA1                       '):
            raise RuntimeError("illegal status data %r" % data[:300])
        for line in lines[1:]:
            if not line or line[0] == 'X':  # 'X' records and empty lines are ignored
                continue
            match = re.search(Statusmeldung.q_record_re, line)
            newdict = {}
            if not match:
                print 'no match', repr(line)
            for key, value in match.groupdict().items():
                newdict[key] = value.strip()
            try:
                if newdict['time']:
                    newdict['timestamp'] = datetime.datetime(int(newdict['date'][4:]), int(newdict['date'][2:4]),
                                                             int(newdict['date'][:2]), int(newdict['time'][:2]),
                                                             int(newdict['time'][2:]))
                else:
                    newdict['timestamp'] = datetime.datetime(int(newdict['date'][4:]), int(newdict['date'][2:4]),
                                                             int(newdict['date'][:2]))
            except ValueError:
                logging.error("malformed timestamp %r|%r" % (newdict['date'], newdict['time']))
                newdict['timestamp'] = datetime.datetime.now()
            newdict['statustext'] = Statusmeldung.statustexte.get(int(newdict['sendungsschluessel']))
            try:
                newdict['sendungsnrversender'] = int(newdict['sendungsnrversender'])
                self.update_sendung(newdict['sendungsnrversender'], newdict)
            except ValueError:
                logging.warning('Problem with invalid id %r for STAT record - ignoring' % newdict['sendungsnrversender'])


================================================
FILE: pyshipping/fortras/test.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
test.py - tests for fortras related functionality

Created by Maximillian Dornseif on 2006-11-19.
You may consider this BSD licensed.
"""

import unittest
from pyshipping.fortras.bordero import _clip, Bordero

_nvecount = 0


class TestPackstueck:

    def __init__(self):
        global _nvecount
        self.gewicht = 160000
        self.nve = '%018d' % (_nvecount)
        _nvecount += 1
        self.trackingnummer = self.nve


class TestLieferung:

    def __init__(self):
        global _nvecount
        self.packstuecke = [TestPackstueck(), TestPackstueck()]
        self.lieferscheinnummer = '123456'
        self.auftragsnummer = '654321'
        self.auftragsnummer_kunde = 'auftragsnummer_kunde'
        self.kundennummer = '54321'
        self.name1 = 'name1-Iñtërnâtiônàlizætiøn-latin1-name1-name1'
        self.name2 = 'name2zulangname2zulangname2zulangname2zulangname2zulangname2zulangname2n'
        self.name3 = 'name3'
        self.name4 = 'nane4'
        self.adresse = 'strassestrassestrassestrassestrassestrassestrasse'
        self.plz = 'plz99999'
        self.ort = 'ortortortortortortortortortortortortortortort'
        self.land = 'DE'
        self.spedition = 'Maeuler'
        self.frankatur = 'frei'
        self.codedata = 'AAAA'
        self.hebebuehne = True
        self.avisieren_unter = '02195-8393'
        self.versandhinweis = 'versandhinweis'
        self.info = 'info'
        self.fixtermin = False
        self.code = 'c0de'
        self.id = _nvecount
        _nvecount += 1

    def _get_gewicht(self):
        return sum([packstueck.gewicht for packstueck in self.packstuecke])
    gewicht = property(_get_gewicht)


class BorderoTests(unittest.TestCase):

    def test_clip(self):
        self.assertEqual(_clip(3, 'ABCDEF'), 'ABC')
        self.assertEqual(_clip(3, 'ABC'), 'ABC')
        self.assertEqual(_clip(5, 'ABC'), 'ABC')
        self.assertEqual(_clip(0, 'ABC'), '')

    def test_bordero(self):
        bordero = Bordero()
        bordero.borderonr = 1
        bordero.add_lieferung(TestLieferung())
        bordero.add_lieferung(TestLieferung())
        bordero.add_lieferung(TestLieferung())
        bordero.generate_dataexport()


# The following tests have an ugly circular dependency to huLOG - this needs fixing

# class StatTests(unittest.TestCase):
#
#     def test_status(self):
#         tesdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L00000000000000545177124         091071120061106                                                                    5\
# '''
#         stat = Statusmeldung()
#         #stat.parse(tesdata)
#
#         testdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L00000000000000395176882         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000385176883         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000375176884         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000365176885         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000355176886         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000345176887         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000335176888         054061120061615                  ROLLKARTE 421/6902                                5
# Q11515     L00000000000000325176890         054061120061615                  ROLLKARTE 421/6902                                5
# '''
#         stat.parse(testdata)
#
#         testdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L00000000000000395176882         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000385176883         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000375176884         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000365176885         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000355176886         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000345176887         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000335176888         012111120061111   UNTERSCHRIFT                                                     5
# Q11515     L00000000000000325176890         012111120061111   UNTERSCHRIFT                                                     5
# '''
#         stat.parse(testdata)
#
#         testdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L00000000009106405176617         012031120061500   TESTNAME                                                         5
# Q11515     L00000000009109205176618         012031120061501   TESTNAME2                                                        5
# Q11515     L00000000009111205176619         012031120061510   TESTNAME3                                                        5
# '''
#         stat.parse(testdata)
#
#         testdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L65827812        5178928         054171120060745                                                                    5
# Q11515     L65827812        5178928         012171120060827   THOMA                                                            5
# Q11515     L232740          5178930         054171120060922                                                                    5
# '''
#         stat.parse(testdata)
#
#         testdata = '''@@PHSTAT128 0128003500107 MAEULER HUDORA1
# Q11515     L6350706         5178934         054171120060726                                                                    5
# Q11515     L6350706         5178934         012171120060911   PATER                                                            5
# '''
#         stat.parse(testdata)
#
#
# class EntlTests(unittest.TestCase):
#
#     def test_entladebericht(self):
#         entl = Entladebericht()
#
#         testdata = '''@@PHENTL128 0128003500107 MAEULER HUDORA1
# M0000000000000000000311200611515     301218990000  301218990000301218990000                                                    5
# W                                                                                                                    EM        5
# N00000000000000000000100000000009106405176617         000                                    0000
# N00000000000000000000200000000009109205176618         000                                    0000
# N00000000000000000000300000000009111205176619         000                                    0000
# '''
#         entl.parse(testdata)
#
#         tesdata = '''@@PHENTL128 0128003500107 MAEULER HUDORA1
# M0000000000000000081611200611515     161120061300  161120061300161120061310                                                    5
# W                                                                                                                    EM        5
# V0000000000000000080000000000000074   00340059980000001166               0                          16112006184200
# '''
#         entl.parse(testdata)
#
#         testdata = '''@@PHENTL128 0128003500107 MAEULER HUDORA1
# M0000000000000000091711200611515     171120061300  171120061310171120061320                                                    5
# W                                                                                                                    EM        5
# V0000000000000000090000000000000104   00340059980000001470               0                          17112006133900
# V0000000000000000090000000000000103   00340059980000001463               0                          17112006134000
# V0000000000000000090000000000000102   00340059980000001456               0                          17112006133900
# V0000000000000000090000000000000101   00340059980000001449               0                          17112006133900
# V0000000000000000090000000000000100   00340059980000001432               0                          17112006134000
# V0000000000000000090000000000000099   00340059980000001425               0                          17112006133900
# V0000000000000000090000000000000098   00340059980000001418               0                          17112006133900
# V0000000000000000090000000000000097   00340059980000001401               0                          17112006133900
# V0000000000000000090000000000000096   00340059980000001395               0                          17112006133900
# V0000000000000000090000000000000095   00340059980000001388               0                          17112006133900
# V0000000000000000090000000000000094   00340059980000001371               0                          17112006134000
# V0000000000000000090000000000000093   00340059980000001364               0                          17112006134000
# V0000000000000000090000000000000092   00340059980000001357               0                          17112006134000
# V0000000000000000090000000000000091   00340059980000001340               0                          17112006134000
# V0000000000000000090000000000000090   00340059980000001333               0                          17112006134000
# V0000000000000000090000000000000089   00340059980000001326               0                          17112006133900
# V0000000000000000090000000000000088   00340059980000001319               0                          17112006133900
# '''
#         entl.parse(testdata)
#
#         testdata = '''@@PHENTL128 0128003500107 MAEULER HUDORA1
# M0000000000000000081611200611515     161120061300  161120061300161120061310                                                    5
# W                                                                                                                    EM        5
# V0000000000000000080000000000000084   00340059980000001272               0                          16112006184200
# V0000000000000000080000000000000083   00340059980000001265               0                          16112006142912
# V0000000000000000080000000000000082   00340059980000001258               0                          16112006184200
# V0000000000000000080000000000000081   00340059980000001241               0                          16112006142913
# V0000000000000000080000000000000080   00340059980000001234               0                          16112006142913
# V0000000000000000080000000000000079   00340059980000001227               0                          16112006142913
# V0000000000000000080000000000000078   00340059980000001210               0                          16112006142913
# V0000000000000000080000000000000077   00340059980000001203               0                          16112006142914
# V0000000000000000080000000000000076   00340059980000001197               0                          16112006184200
# V0000000000000000080000000000000075   00340059980000001180               0                          16112006142914
# V0000000000000000080000000000000074   00340059980000001173               0                          16112006184200
# V461               720-00             00340498430009431112               0                          19092008183100
# '''
#         entl.parse(testdata)
#
if __name__ == '__main__':
    unittest.main()


================================================
FILE: pyshipping/package.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
package.py - shipping/cargo related calculations based on a unit of shipping (box, crate, package)

Created by Maximillian Dornseif on 2006-12-02.
Copyright HUDORA GmbH 2006, 2007, 2010
You might consider this BSD-Licensed.
"""

import doctest
import unittest


class Package(object):
    """Represents a package as used in cargo/shipping aplications."""

    def __init__(self, size, weight=0, nosort=False):
        """Generates a new Package object.

        The size can be given as an list of integers or an string where the sizes are
        separated by the letter 'x':
        >>> Package((300, 400, 500))
        <Package 500x400x300>
        >>> Package('300x400x500')
        <Package 500x400x300>
        """
        self.weight = weight
        if "x" in size:
            self.heigth, self.width, self.length = [int(x) for x in size.split('x')]
        else:
            self.heigth, self.width, self.length = size
        if not nosort:
            (self.heigth, self.width, self.length) = sorted((int(self.heigth), int(self.width),
                                                             int(self.length)), reverse=True)
        self.volume = self.heigth * self.width * self.length
        self.size = (self.heigth, self.width, self.length)

    def _get_gurtmass(self):
        """'gurtamss' is the circumference of the box plus the length - which is often used to
            calculate shipping costs.

            >>> Package((100,110,120)).gurtmass
            540
        """

        dimensions = (self.heigth, self.width, self.length)
        maxdimension = max(dimensions)
        otherdimensions = list(dimensions)
        del otherdimensions[otherdimensions.index(maxdimension)]
        return maxdimension + 2 * (sum(otherdimensions))
    gurtmass = property(_get_gurtmass)

    def hat_gleiche_seiten(self, other):
        """Prüft, ob other mindestens eine gleich grosse Seite mit self hat."""

        meineseiten = set([(self.heigth, self.width), (self.heigth, self.length), (self.width, self.length)])
        otherseiten = set([(other.heigth, other.width), (other.heigth, other.length),
                           (other.width, other.length)])
        return bool(meineseiten.intersection(otherseiten))

    def __getitem__(self, key):
        """The coordinates can be accessed as if the object is a tuple.
        >>> p = Package((500, 400, 300))
        >>> p[0]
        500
        """
        if key == 0:
            return self.heigth
        if key == 1:
            return self.width
        if key == 2:
            return self.length
        if isinstance(key, tuple):
            return (self.heigth, self.width, self.length)[key[0]:key[1]]
        if isinstance(key, slice):
            return (self.heigth, self.width, self.length)[key]
        raise IndexError

    def __contains__(self, other):
        """Checks if on package fits within an other.

        >>> Package((1600, 250, 480)) in Package((1600, 250, 480))
        True
        >>> Package((1600, 252, 480)) in Package((1600, 250, 480))
        False
        """
        return self[0] >= other[0] and self[1] >= other[1] and self[2] >= other[2]

    def __hash__(self):
        return self.heigth + (self.width << 16) + (self.length << 32)

    def __eq__(self, other):
        """Package objects are equal if they have exactly the same dimensions.

           Permutations of the dimensions are considered equal:

           >>> Package((100,110,120)) == Package((100,110,120))
           True
           >>> Package((120,110,100)) == Package((100,110,120))
           True
        """
        return (self.heigth == other.heigth and self.width == other.width and self.length == other.length)

    def __cmp__(self, other):
        """Enables to sort by Volume."""
        return cmp(self.volume, other.volume)

    def __mul__(self, multiplicand):
        """Package can be multiplied with an integer. This results in the Package beeing
           stacked along the biggest side.

           >>> Package((400,300,600)) * 2
           <Package 600x600x400>
           """
        if self.weight:
            new_weight = self.weight * multiplicand
        else:
            new_weight = None
        return Package((self.heigth, self.width, self.length * multiplicand), new_weight)

    def __add__(self, other):
        """
            >>> Package((1600, 250, 480)) + Package((1600, 470, 480))
            <Package 1600x720x480>
            >>> Package((1600, 250, 480)) + Package((1600, 480, 480))
            <Package 1600x730x480>
            >>> Package((1600, 250, 480)) + Package((1600, 490, 480))
            <Package 1600x740x480>
            """
        meineseiten = set([(self.heigth, self.width), (self.heigth, self.length),
                           (self.width, self.length)])
        otherseiten = set([(other.heigth, other.width), (other.heigth, other.length),
                           (other.width, other.length)])
        if not meineseiten.intersection(otherseiten):
            raise ValueError("%s has no fitting sites to %s" % (self, other))
        candidates = sorted(meineseiten.intersection(otherseiten), reverse=True)
        stack_on = candidates[0]
        mysides = [self.heigth, self.width, self.length]
        mysides.remove(stack_on[0])
        mysides.remove(stack_on[1])
        othersides = [other.heigth, other.width, other.length]
        othersides.remove(stack_on[0])
        othersides.remove(stack_on[1])

        if self.weight and other.weight:
            new_weight = self.weight + other.weight
        else:
            new_weight = None

        return Package((stack_on[0], stack_on[1], mysides[0] + othersides[0]), new_weight)

    def __str__(self):
        if self.weight:
            return "%dx%dx%d %dg" % (self.heigth, self.width, self.length, self.weight)
        else:
            return "%dx%dx%d" % (self.heigth, self.width, self.length)

    def __repr__(self):
        if self.weight:
            return "<Package %dx%dx%d %d>" % (self.heigth, self.width, self.length, self.weight)
        else:
            return "<Package %dx%dx%d>" % (self.heigth, self.width, self.length)


def buendelung(kartons, maxweight=31000, maxgurtmass=3000):
    """Versucht Pakete so zu bündeln, so dass das Gurtmass nicht überschritten wird.

    Gibt die gebündelten Pakete und die nicht bündelbaren Pakete zurück.

    >>> buendelung([Package((800, 310, 250)), Package((800, 310, 250)), Package((800, 310, 250)), Package((800, 310, 250))])
    (1, [<Package 800x750x310>], [<Package 800x310x250>])
    >>> buendelung([Package((800, 310, 250)), Package((800, 310, 250)), Package((800, 310, 250)), Package((800, 310, 250)), Package((450, 290, 250)), Package((450, 290, 250))])
    (2, [<Package 800x750x310>, <Package 500x450x290>], [<Package 800x310x250>])
    """
    kartons = list(kartons)

    def buendelung_moeglich(box_a, box_b):
        """Entscheide, ob eine Bündelung der beiden Kartons möglich ist.

        Es kann gebündelt werden, wenn die Summe der Gewichte (falls gepflegt)
        kleiner ist als das maximale Gewicht,
        das Gurtmaß nicht das maximale Gurtmaß übersteigt
        und nicht bereits die maximale Anzahl der Bündelungen erreicht ist.
        """

        if kartons_im_buendel > MAXKARTONSIMBUENDEL:
            return False

        tmp = box_a + box_b
        if tmp.weight > maxweight:
            return False
        elif tmp.gurtmass > maxgurtmass:
            return False
        return True

    MAXKARTONSIMBUENDEL = 6
    if not kartons:
        return 0, [], kartons
    gebuendelt = []
    rest = []
    lastcarton = kartons.pop(0)
    buendel = False
    buendelcounter = 0
    kartons_im_buendel = 1
    while kartons:
        currentcarton = kartons.pop(0)
        # check if 2 dimensions fit and bundling is possible
        if currentcarton.hat_gleiche_seiten(lastcarton) and buendelung_moeglich(lastcarton, currentcarton):
            # new carton has the same size in two dimensions and the sum of both in the third
            lastcarton = lastcarton + currentcarton
            kartons_im_buendel += 1
            if buendel is False:
                # neues Bündel
                buendelcounter += 1
            buendel = True
        else:
            # different sizes, or too big
            if buendel:
                gebuendelt.append(lastcarton)
            else:
                rest.append(lastcarton)
            kartons_im_buendel = 1
            lastcarton = currentcarton
            buendel = False
    if buendel:
        gebuendelt.append(lastcarton)
    else:
        rest.append(lastcarton)
    return buendelcounter, gebuendelt, rest


def pack_in_bins(kartons, versandkarton):
    """Implements Bin-Packing.

    You provide it with a bin size and a list of Package Objects to be bined. Returns a list of lists
    representing the bins with the binned Packages and a list of Packages too big for binning.

    >>> pack_in_bins([Package('135x200x250'), Package('170x380x390'), Package('485x280x590'), Package('254x171x368'), Package('201x172x349'), Package('254x171x368')], \
                     Package('600x400x400'))
    ([[<Package 250x200x135>, <Package 349x201x172>, <Package 368x254x171>], [<Package 368x254x171>, <Package 390x380x170>]], [<Package 590x485x280>])
    """

    import pyshipping.binpack
    toobig, packagelist, bins, rest = [], [], [], []
    for box in sorted(kartons, reverse=True):
        if box not in versandkarton:
            # passt eh nicht
            toobig.append(box)
        else:
            packagelist.append(box)
    if packagelist:
        bins, rest = pyshipping.binpack.binpack(packagelist, versandkarton)
    return bins, toobig + rest


### Tests
class PackageTests(unittest.TestCase):
    """Simple tests for Package objects."""

    def test_init(self):
        """Tests object initialisation with different constructors."""
        self.assertEqual(Package((100, 100, 200)), Package(('100', '200', '100')))
        self.assertEqual(Package((100.0, 200.0, 200.0)), Package('200x200x100'))

    def test_eq(self):
        """Tests __eq__() implementation."""
        self.assertEqual(Package((200, 100, 200)), Package(('200', '100', '200')))
        self.assertNotEqual(Package((200, 200, 100)), Package(('100', '100', '200')))

    def test_volume(self):
        """Tests volume calculation"""
        self.assertEqual(4000000, Package((100, 200, 200)).volume)
        self.assertEqual(8000, Package((20, 20, 20)).volume)

    def test_str(self):
        """Test __unicode__ implementation."""
        self.assertEqual('200x200x100', Package((100, 200, 200)).__str__())
        self.assertEqual('200x200x100', Package('100x200x200').__str__())

    def test_repr(self):
        """Test __repr__ implementation."""
        self.assertEqual('<Package 200x200x100 44>', Package((100, 200, 200), 44).__repr__())

    def test_gurtmass(self):
        """Test gurtmass calculation."""
        self.assertEqual(800, Package((100, 200, 200)).gurtmass)
        self.assertEqual(900, Package((100, 200, 300)).gurtmass)
        self.assertEqual(1000, Package((200, 200, 200)).gurtmass)
        self.assertEqual(3060, Package((1600, 250, 480)).gurtmass)

    def test_mul(self):
        """Test multiplication."""
        self.assertEqual(Package((200, 200, 200)), Package((100, 200, 200)) * 2)

    def test_sort(self):
        """Test multiplication."""
        data = [Package((1600, 490, 480)), Package((1600, 470, 480)), Package((1600, 480, 480))]
        data.sort()
        self.assertEqual(data,
                         [Package((1600, 470, 480)), Package((1600, 480, 480)),
                          Package((1600, 490, 480))])


if __name__ == '__main__':

    factor = 0
    while True:
        factor += 1
        single = Package((750, 240, 220), 7400)
        multi = single * factor
        if multi.weight > 31000 or multi.gurtmass > 3000:
            multi = single * (factor - 1)
            #print factor - 1, multi, multi.gurtmass
            break

    doctest.testmod()
    unittest.main()


================================================
FILE: pyshipping/shipment.py
================================================
#!/usr/bin/env python
# encoding: utf-8
"""
sendung.py - Sendungsaufteilung - dies definiert eine abstrakte Sendung, mit Packstücken usw. und
             Operationen darauf.

Created by Maximillian Dornseif on 2007-07-11. Based on code from 2007-04-17.
Copyright (c) 2007 HUDORA GmbH. All rights reserved.
"""

import unittest
import math


class AbstractPackstueck(object):
    """Definiert ein Packstück, d.h. eine Versandeinheit. In der Regel eine Palette oder ein Karton"""
    pass


class AbstractItem(object):
    """Definiert ein Sendungsposition. In der Regel definiert als Artikel und Menge."""
    # Kann in der Theorie aus mehreren Packstücken bestehen, das ist aber noch nicht implementeirt.
    def __init__(self):
        # Wir gehen davon aus, dass folgende Attribute von ausserhalb oder von abgeleiteten Klassen
        # definiert wird:
        #self.gewicht_pro_exportkarton = None
        #self.palettenfaktor = None
        #self.produkte_pro_exportkarton = None
        #self.einzelvolumen = None
        #self.einzelgewicht = None
        self.menge = None

    def __unicode__(self):
        if hasattr(self, 'liefertermin') and hasattr(self, 'artnr'):
            return u"%d x %s, %s" % (self.menge, self.artnr, self.liefertermin)
        if hasattr(self, 'artnr'):
            return u"%d x %s" % (self.menge, self.artnr)
        return u"%d x ?????" % (self.menge)

    @property
    def anbruch(self):
        """Returns True if this Item does not result in an export_package to be opened."""
        return (self.menge % self.produkte_pro_exportkarton) != 0

    @property
    def volumen(self):
        """Retuns the volume of this item in m^3."""
        # TODO: Exportkartonvolumen
        return self.menge * self.einzelvolumen

    @property
    def gewicht(self):
        """Retuns the weight of this item in g."""
        # TODO: Exportkartongewicht usw.
        return self.menge * self.einzelgewicht

    @property
    def max_packstueck_gewicht(self):
        """Returns the weigtht of the most heavy box for ths item."""
        if self.menge >= self.produkte_pro_exportkarton:
            return self.gewicht_pro_exportkarton
        return (self.gewicht_pro_exportkarton / self.produkte_pro_exportkarton) * self.menge

    @property
    def paletten(self):
        """Returns the number of pallets of this Item."""
        return float(self.menge) / float(self.palettenfaktor)

    @property
    def picks(self):
        """Returns the number storage locations to be accessed to get the item."""
        picks = self.paletten
        # round up
        if picks != int(picks):
            picks = int(picks + 1)
        return picks

    @property
    def export_kartons(self):
        """Returns the number of export packages needed to fullfill this item as a float."""
        return self.menge / float(self.produkte_pro_exportkarton)

    @property
    def export_karton_gewichte(self):
        """Returns the weights of the estimated number of packages which will be shipped in gramms."""
        menge = self.menge
        ret = []
        while menge:
            if menge > self.produkte_pro_exportkarton:
                ret.append(self.gewicht_pro_exportkarton)
                menge -= self.produkte_pro_exportkarton
            else:
                ret.append(menge * self.einzelgewicht)
                menge = 0
        return ret

    @property
    def packstuecke(self):
        """Returns the absolute number of packages to fullfill this item as an integer.

        This could take into account that packages can be bundled etc.
        """

        packstuecke = self.export_kartons
        # round up
        if packstuecke != int(packstuecke):
            packstuecke = int(packstuecke + 1)
        return int(packstuecke)


class AbstractLieferung(object):
    """Definiert eine Lieferung. Das ist eine Einheit aus Positionen und Packstuecken."""

    def __init__(self):
        # Wir gehen davon aus, dass folgende arrtibute von ausserhalb oder von abgeleiteten Klassen
        # definiert wird:
        self.fix = False  # the liefertermin is advisory or mandantory
        self.liefertermin = None
        self.itemlist = []

    @property
    def transportweg(self):
        """Returns the suggested method of shipping."""
        pass

    @property
    def transportzeit(self):
        """Returns the number of days this is likely to take to be shipped to the client."""
        pass

    @property
    def versandtermin(self):
        """Retuns the suggested date of shipping."""
        try:
            return self.liefertermin - self.transportzeit
        except TypeError:
            return self.liefertermin

    @property
    def anbruch(self):
        """Returns False if this Lieferung contains no items which need a export_package to be opened."""
        for item in self.itemlist:
            if item.anbruch:
                return True
        return False

    @property
    def volumen(self):
        """Returns the volume of all Items in this Lieferung in m^3."""
        return sum([x.volumen for x in self.itemlist])

    @property
    def gewicht(self):
        """Returns the gewicht of all Items in this Lieferung in g."""
        return sum([x.gewicht for x in self.itemlist])

    @property
    def max_packstueck_gewicht(self):
        """Returns the highest gewicht of any package in the shippment in g."""
        if self.itemlist:
            return max([x.max_packstueck_gewicht for x in self.itemlist])
        return 0

    @property
    def paletten(self):
        """Returns the number of pallets of all Items in this Lieferung."""
        return sum([x.paletten for x in self.itemlist])

    @property
    def versandpaletten(self):
        """Returns the number of pallets to be shipped. Always an Integer"""
        return math.ceil(self.paletten)

    @property
    def picks(self):
        """Returns the number of estimated picks for this Lieferung.

        A pick is defined as accessing a position in the warehouse."""
        return sum([x.picks for x in self.itemlist])

    @property
    def packstuecke(self):
        """Returns the number of "Greifeinheiten", meaning units to be taken out o the warehouse.
        This is an integer."""
        return sum([x.packstuecke for x in self.itemlist])

    @property
    def export_kartons(self):
        """Returns the estimated number of packages which will be shipped. This is a float."""
        return sum([x.export_kartons for x in self.itemlist])

    @property
    def export_karton_gewichte(self):
        """Returns the weights of the estimated number of packages which will be shipped in gramms."""
        ret = []
        for box in self.itemlist:
            ret.extend(box.export_karton_gewichte)
        return ret

    @property
    def kep(self):
        """Entscheidet, ob die Sendung mit einem Paketdienstleister verchickt werden kann."""
        if self.export_kartons > 10:
            return False
        if self.max_packstueck_gewicht > 31500:
            return False
        return True


class simpleTests(unittest.TestCase):
    """Very basic testing functionality."""

    def test_stupid(self):
        """Basic plausibility tests."""
        aitem = AbstractItem()
        aitem.menge = 12
        aitem.einzelgewicht = 3333
        aitem.palettenfaktor = 70
        aitem.produkte_pro_exportkarton = 2
        aitem.einzelvolumen = (750 * 200 * 100) / 10 / 10 / 10
        self.assertEqual(aitem.volumen, 180000)  # TODO: Unit? TOO BIG
        self.assertEqual(aitem.gewicht, 39996)
        self.assertEqual(aitem.anbruch, False)
        self.assertAlmostEqual(aitem.paletten, 0.171428571429)
        # print aitem.feinkommissionierung
        aitem2 = AbstractItem()
        aitem2.menge = 17
        aitem2.einzelgewicht = 9123
        aitem2.palettenfaktor = 30
        aitem2.produkte_pro_exportkarton = 5
        aitem2.einzelvolumen = (750 * 200 * 100) / 10 / 10 / 10

        alieferung = AbstractLieferung()
        alieferung.itemlist = [aitem]
        self.assertEqual(alieferung.volumen, 180000)  # TODO: Unit? TOO BIG
        self.assertEqual(alieferung.gewicht, 39996)
        self.assertEqual(alieferung.anbruch, False)
        self.assertAlmostEqual(alieferung.paletten, 0.171428571429)
        # print alieferung.fix
        # print alieferung.feinkommissionierung
        # print alieferung.transportzeit
        # print alieferung.versandtermin
        # print alieferung.liefertermin
        alieferung.itemlist = [aitem, aitem2]
        self.assertEqual(alieferung.volumen, 435000)
        self.assertEqual(alieferung.gewicht, 195087)
        self.assertAlmostEqual(alieferung.paletten, 0.738095238095)
        # print alieferung.transportweg
        # print alieferung.fix

if __name__ == '__main__':
    unittest.main()


================================================
FILE: requirements.txt
================================================
# nothing


================================================
FILE: setup.py
================================================
long_description = """
pyShipping provides connections to interface with shipping companies and to transport shipping related
information.
"""

from setuptools import setup, find_packages
from distutils.extension import Extension
import codecs

setup(name='pyShipping',
      maintainer='Maximillian Dornseif',
      maintainer_email='md@hudora.de',
      url="https://github.com/hudora/pyShipping/",
      version='1.9',
      description='pyShipping - Shipping related Toolkit',
      long_description=codecs.open('README.rst', "r", "utf-8").read(),
      classifiers=['License :: OSI Approved :: BSD License',
                   'Intended Audience :: Developers',
                   'Programming Language :: Python'],
      # download_url
      zip_safe=False,
      packages=find_packages(),
      package_data={'': ['README.rst'], 'pyshipping': ['carriers/dpd/georoutetables/*']},
      include_package_data=True,
      # cmdclass = {'build_ext': build_ext}
)



================================================
FILE: testdata.txt
================================================
153x64x64 153x64x64
580x140x60 580x140x60 
580x190x60 580x190x60 
580x210x60 580x210x60 
240x62x43 240x62x43
220x200x80 177x55x55
133x133x50 210x210x80
470x380x80 470x380x80
133x133x50 133x133x50
490x330x90 490x330x90
440x180x70 440x180x70
310x195x185 145x75x60
133x133x50 133x133x50
390x260x85 390x260x85
500x300x80 500x300x80
470x380x80 470x380x80
500x300x80 500x300x80
320x140x70 320x140x70
490x330x90 490x330x90
170x95x90 267x230x220
490x330x90 490x330x90
530x385x250 470x380x80
310x230x70 340x280x120
340x180x180 220x105x75
470x380x80 220x160x120
490x330x90 400x370x330
290x210x160 585x285x200
450x290x250 450x290x250
298x241x216 298x241x216
430x135x135 430x135x135
370x350x340 535x400x180
540x400x245 435x230x230
260x205x135 260x205x135
470x390x120 470x390x120
390x285x140 190x190x120
553x261x152 430x135x135
260x205x135 580x260x255
390x380x170 365x305x280
185x140x138 185x140x138
250x200x135 340x280x190
260x155x105 340x280x190
430x135x135 430x135x135
430x300x200 430x300x200
480x215x140 480x215x140
185x140x138 185x140x138
450x290x250 450x290x250
520x330x320 520x330x320
430x350x110 430x350x110
580x235x200 580x235x200
360x340x170 585x285x200
270x240x160 270x240x160
485x400x255 485x400x255
375x365x215 390x365x273
180x160x100 180x160x100
400x390x170 580x235x200
390x285x140 430x135x135
360x340x170 430x135x135
390x285x140 520x330x200
450x290x250 430x135x135
405x280x195 405x280x195
430x135x135 430x135x135
190x190x120 280x230x180
390x285x140 280x230x180
440x360x330 440x360x330
373x323x283 473x323x283
250x200x135 250x200x135
390x330x210 480x215x140
480x215x140 480x215x140
185x165x100 185x165x100
250x200x135 185x165x100
390x285x140 390x285x140
340x280x190 340x280x190
345x220x130 340x280x190
365x305x280 280x230x180
185x165x100 185x165x100
390x285x140 520x330x200
520x330x320 510x300x150
240x225x160 240x225x160
230x53x53 230x53x53 230x53x53
145x75x60 145x75x60 145x75x60
145x75x60 140x110x25 140x110x25
185x140x138 160x48x35 160x48x35
410x250x50 410x250x50 410x250x50
425x230x52 425x230x52 425x230x52
490x330x90 490x330x90 490x330x90
440x180x70 440x180x70 440x180x70
490x330x90 490x330x90 260x205x135
340x280x190 440x180x70 440x180x70
490x330x90 490x330x90 190x190x120
130x90x80 440x190x190 340x280x190
360x340x170 320x140x70 320x140x70
390x365x273 285x265x245 145x75x60
390x365x273 295x190x170 145x75x60
475x355x285 475x355x285 475x355x285
215x205x105 215x205x105 215x205x105
470x180x103 470x180x103 470x180x103
195x150x114 195x150x114 245x165x120
473x323x283 290x210x160 520x330x200
553x261x152 290x210x160 430x135x135
220x160x120 220x160x120 220x160x120
220x210x180 220x210x180 220x210x180
430x300x200 520x330x200 430x135x135
298x241x216 298x241x216 298x241x216
220x210x180 220x210x180 295x190x170
470x180x103 470x180x103 470x180x103
430x135x135 430x135x135 430x135x135
520x330x200 365x305x280 580x260x255
360x340x170 450x290x250 520x330x200
520x330x200 430x135x135 430x135x135
470x180x103 470x180x103 470x180x103
410x270x150 390x230x140 345x205x145
520x350x315 460x400x115 430x360x242
405x400x380 405x400x380 405x400x380
485x400x255 410x360x115 330x240x160
553x261x152 280x230x180 280x230x180
127x127x127 127x127x127 127x127x127
220x210x180 285x265x245 580x235x200
360x340x170 520x330x200 430x135x135
430x300x200 390x285x140 430x135x135
473x323x283 473x323x283 430x135x135
280x230x180 430x135x135 430x135x135
310x180x100 310x180x100 310x180x100
390x340x210 185x185x105 185x185x105
450x290x250 250x200x135 250x200x135
340x240x170 340x240x170 340x240x170
470x180x103 470x180x103 470x180x103
540x400x245 330x190x100 330x190x100
450x250x160 450x250x160 450x250x160
400x370x330 520x330x200 585x285x200
250x200x135 250x200x135 250x200x135
340x280x190 340x280x190 340x280x190
127x127x127 127x127x127 127x127x127
460x335x185 340x300x240 340x300x240
405x400x380 280x160x120 280x160x120
390x285x140 390x285x140 390x285x140
295x190x170 295x190x170 285x265x245
340x280x190 340x280x190 340x280x190
590x380x280 590x380x280 590x380x280
245x235x155 245x235x155 245x235x155
530x385x250 600x400x120 600x400x120
540x230x160 540x230x160 540x230x160
390x365x273 375x365x215 580x235x200
185x185x105 185x185x105 185x185x105
368x254x171 349x201x172 368x254x171
400x370x330 553x261x152 290x210x160
310x300x210 290x210x160 520x330x200
445x260x185 445x260x185 445x260x185
230x90x20 230x90x20 230x90x20 230x90x20
570x220x35 570x220x35 160x60x60 160x60x60
125x125x75 125x125x75 125x125x75 125x125x75
425x230x52 425x230x52 425x230x52 425x230x52
330x280x80 450x310x38 305x205x25 235x155x70
500x300x80 500x300x80 500x300x80 500x300x80
160x150x35 160x150x35 160x150x35 160x150x35
490x330x90 490x330x90 490x330x90 360x295x185
490x330x90 490x330x90 180x160x100 180x160x100
490x330x90 490x330x90 270x240x160 270x240x160
360x340x170 320x140x70 320x140x70 270x240x160
480x215x140 500x300x80 500x300x80 440x190x190
295x190x170 240x225x160 250x150x90 250x150x90
575x360x310 365x305x280 330x280x80 330x280x80
480x210x190 480x210x190 305x205x25 305x205x25
460x335x185 460x335x185 450x310x38 450x310x38
490x330x90 490x330x90 190x190x120 280x230x180
298x268x241 298x268x241 380x280x65 280x160x120
580x320x108 490x330x90 260x230x160 180x160x100
410x250x50 440x270x100 440x270x100 440x270x100
270x240x160 380x280x65 298x241x216 349x201x172
390x285x140 390x285x140 390x285x140 390x140x80
370x350x340 370x350x340 500x355x315 380x280x65
473x323x283 473x323x283 473x323x283 553x261x152
250x205x140 250x205x140 250x205x140 250x205x140
450x250x160 450x250x160 450x250x160 450x250x160
470x180x103 470x180x103 470x180x103 580x260x255
370x290x110 195x150x114 195x150x114 245x165x120
365x305x280 280x230x180 390x230x140 580x260x255
290x210x160 430x135x135 430x135x135 585x285x200
450x290x250 450x290x250 450x290x250 450x290x250
270x240x160 270x240x160 365x305x280 260x205x135
450x290x250 430x135x135 430x135x135 430x135x135
270x210x100 270x210x100 260x230x160 260x230x160
430x360x242 485x400x255 260x215x170 180x160x100
270x240x160 270x240x160 180x160x100 180x160x100
430x300x200 430x135x135 430x135x135 430x135x135
450x290x250 450x290x250 450x290x250 450x290x250
298x286x260 390x285x140 430x135x135 280x160x120
405x400x380 600x400x290 370x350x340 360x340x170
330x190x100 330x190x100 330x190x100 330x190x100
360x340x170 390x285x140 520x330x200 430x135x135
390x380x170 410x270x150 440x190x190 440x190x190
430x300x200 430x300x200 450x290x250 430x135x135
553x261x152 390x285x140 390x285x140 430x135x135
460x335x185 460x335x185 460x335x185 460x335x185
390x358x265 520x330x320 480x215x140 340x300x240
280x230x180 390x285x140 520x330x200 430x135x135
280x230x180 520x330x200 430x135x135 430x135x135
405x280x195 405x280x195 405x280x195 405x280x195
390x285x140 190x190x120 280x230x180 280x230x180
250x200x135 250x200x135 340x280x190 340x280x190
425x320x300 260x210x160 260x230x160 345x220x130
473x323x283 473x323x283 473x323x283 473x323x283
310x300x225 310x300x225 345x220x130 345x220x130
540x230x160 210x148x100 210x148x100 210x148x100
390x285x140 520x330x200 430x135x135 430x135x135
340x240x170 345x205x145 485x400x255 430x360x242
520x330x320 520x330x320 260x230x160 250x205x140
450x250x160 450x250x160 450x250x160 450x250x160
440x370x350 440x370x350 440x370x350 580x235x200
450x250x160 450x250x160 450x250x160 450x250x160
430x360x242 485x400x255 260x220x120 320x220x180
340x280x190 340x280x190 340x280x190 340x280x190
250x200x135 250x200x135 250x200x135 250x200x135
480x215x140 345x205x145 345x205x145 345x205x145
390x290x140 390x290x140 390x290x140 390x290x140
340x280x190 340x280x190 340x280x190 340x280x190
250x200x135 250x200x135 250x200x135 250x200x135
250x200x135 250x200x135 390x380x170 390x380x170
405x280x195 405x280x195 405x280x195 255x190x175
475x355x285 475x355x285 475x355x285 475x355x285
145x75x60 145x75x60 145x75x60 145x75x60 145x75x60
288x62x43 288x62x43 288x62x43 288x62x43 288x62x43
295x190x170 160x94x50 160x94x50 160x94x50 160x94x50
160x94x50 160x94x50 160x94x50 160x94x50 580x235x200
295x190x170 160x94x50 160x94x50 160x94x50 160x94x50
145x75x60 145x75x60 145x75x60 260x230x160 260x230x160
570x220x35 570x220x35 570x220x35 570x220x35 390x285x140
340x280x190 275x170x40 275x170x40 275x170x40 275x170x40
380x260x75 380x260x75 345x205x145 410x270x150 425x230x52
490x330x90 490x330x90 470x180x103 470x180x103 470x180x103
450x290x250 380x260x75 380x260x75 260x210x160 340x280x120
270x240x160 520x330x200 310x230x70 260x160x160 490x330x90
473x323x283 300x245x70 470x390x120 470x390x120 570x220x35
430x135x135 250x150x90 390x285x140 270x240x160 580x260x255
500x300x80 430x135x135 430x135x135 250x200x135 260x210x160
460x335x185 460x335x185 450x290x250 490x330x90 480x215x140
490x330x90 445x205x120 445x205x120 445x205x120 445x205x120
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
165x60x60 165x60x60 165x60x60 165x60x60 165x60x60 165x60x60
473x323x283 473x323x283 473x323x283 473x323x283 553x261x152
390x365x273 375x365x215 295x190x170 580x235x200 580x235x200
470x180x103 470x180x103 470x180x103 365x305x280 260x205x135
360x340x170 553x261x152 390x285x140 430x135x135 430x135x135
340x240x170 340x240x170 340x240x170 250x205x140 250x205x140
230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53
220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
473x323x283 473x323x283 473x323x283 430x300x200 390x285x140
220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
515x400x265 520x330x200 410x270x150 345x205x145 553x261x152
480x215x140 390x280x135 180x160x100 345x220x130 390x380x170
405x400x380 405x400x380 405x400x380 405x400x380 480x215x140
460x310x310 185x165x100 185x165x100 250x205x140 368x254x171
260x220x120 260x220x120 260x220x120 260x220x120 260x220x120
345x220x130 345x220x130 340x280x120 340x280x120 185x165x100
580x320x108 580x320x108 580x320x108 580x320x108 580x320x108
298x286x260 317x317x260 440x300x230 470x390x120 470x390x120
430x300x200 430x300x200 360x340x170 390x285x140 585x285x200
220x210x180 390x285x140 520x330x200 345x205x145 553x261x152
520x330x320 330x190x100 390x285x140 430x135x135 430x135x135
572x292x175 572x292x175 572x292x175 572x292x175 572x292x175
200x200x200 200x200x200 200x200x200 200x200x200 200x200x200
405x280x195 405x280x195 405x280x195 405x280x195 405x280x195
473x323x283 473x323x283 473x323x283 430x300x200 390x285x140
520x330x320 430x360x242 430x360x242 435x230x230 580x235x200
280x230x180 280x230x180 520x330x200 430x135x135 430x135x135
430x300x200 400x370x330 390x285x140 520x330x200 430x135x135
245x235x155 245x235x155 245x235x155 245x235x155 245x235x155
235x185x180 235x185x180 240x225x160 240x225x160 240x225x160
410x270x150 480x205x110 480x205x110 480x205x110 480x205x110
340x280x190 340x280x190 340x280x190 340x280x190 317x317x260
520x330x320 430x360x242 430x360x242 435x230x230 580x235x200
390x365x273 575x360x310 400x400x300 340x240x170 580x390x280
430x300x200 430x300x200 400x370x330 390x285x140 585x285x200
430x300x200 400x370x330 553x261x152 290x210x160 390x285x140
160x94x50 160x94x50 160x94x50 160x94x50 580x235x200 295x190x170
295x190x170 580x235x200 160x94x50 160x94x50 160x94x50 160x94x50
300x220x210 300x220x210 450x90x30 450x90x30 450x90x30 450x90x30
340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40
298x241x216 490x330x90 490x330x90 490x330x90 490x330x90 425x230x52
460x335x185 520x330x200 340x280x190 270x210x70 380x280x65 100x80x80
400x180x110 400x180x110 390x140x80 390x140x80 390x140x80 390x140x80
375x365x215 295x190x170 285x265x245 280x155x115 160x94x50 160x94x50
575x360x310 490x330x90 490x330x90 520x330x200 260x205x135 390x230x140
385x290x150 440x350x280 430x135x135 430x135x135 250x150x90 250x150x90
473x323x283 473x323x283 470x390x120 470x390x120 145x75x60 430x135x135
260x200x165 260x160x160 490x330x90 490x330x90 390x285x140 260x155x105
490x330x90 490x330x90 470x180x103 470x180x103 470x180x103 580x260x255
590x380x280 590x380x280 590x380x280 590x380x280 590x380x280 320x185x20
430x300x200 430x300x200 390x285x140 390x285x140 430x135x135 430x135x135
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
580x390x280 580x390x280 580x390x280 580x390x280 415x390x315 415x390x315
553x261x152 290x210x160 290x210x160 430x135x135 430x135x135 430x135x135
400x280x205 310x195x185 560x310x280 345x220x130 345x220x130 298x286x260
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
430x300x200 360x340x170 553x261x152 290x210x160 390x285x140 430x135x135
430x300x200 430x300x200 430x300x200 430x300x200 430x135x135 430x135x135
390x340x210 220x210x180 430x360x242 520x330x200 480x215x140 280x155x115
220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
450x290x250 372x365x219 430x300x200 390x390x230 540x400x245 540x400x245
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195
473x323x283 473x323x283 390x285x140 520x330x200 430x135x135 430x135x135
430x300x200 390x285x140 520x330x200 430x135x135 430x135x135 430x135x135
430x300x200 360x340x170 280x230x180 390x285x140 430x135x135 430x135x135
450x290x250 480x215x140 480x215x140 480x215x140 340x280x190 340x280x190
560x310x280 560x310x280 560x310x280 560x310x280 560x310x280 560x310x280
290x210x160 290x210x160 330x190x100 330x190x100 330x190x100 330x190x100
372x365x219 430x300x200 430x300x200 360x340x170 360x340x170 410x335x330
600x320x230 600x320x230 600x320x230 290x210x160 290x210x160 290x210x160
473x323x283 473x323x283 473x323x283 473x323x283 390x285x140 390x285x140
160x94x50 160x94x50 160x94x50 160x94x50 580x235x200 580x235x200 295x190x170
220x210x180 375x365x215 295x190x170 160x94x50 160x94x50 160x94x50 160x94x50
500x300x80 500x300x80 500x300x80 490x230x60 490x230x60 490x230x60 490x230x60
340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 365x305x280
340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 280x230x180
298x241x216 298x241x216 250x180x90 250x180x90 250x180x90 250x180x90 250x180x90
318x318x260 318x318x260 330x240x70 330x240x70 330x240x70 330x240x70 330x240x70
390x260x85 390x260x85 390x260x85 390x260x85 390x260x85 240x225x160 240x225x160
440x20x10 440x20x10 440x20x10 440x20x10 440x20x10 440x20x10 440x20x10 440x20x10
553x261x152 490x330x90 490x330x90 490x330x90 345x220x130 250x150x90 180x160x100
400x250x45 400x250x45 400x250x45 440x370x350 440x370x350 440x370x350 440x370x350
515x400x265 600x400x290 260x210x160 480x215x140 480x215x140 380x260x75 380x260x75
490x230x60 490x230x60 480x215x140 250x200x135 250x200x135 250x200x135 250x200x135
430x360x242 298x241x216 390x285x140 185x165x100 250x200x135 380x280x65 340x280x190
340x240x170 585x285x200 250x205x140 400x370x330 250x150x90 390x230x140 445x205x120
270x240x160 270x240x160 470x180x103 470x180x103 470x180x103 280x230x180 580x260x255
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 345x220x130
220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
430x300x200 280x230x180 280x230x180 390x285x140 390x285x140 520x330x200 430x135x135
572x292x175 572x292x175 572x292x175 572x292x175 572x292x175 572x292x175 572x292x175
473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 390x285x140
250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135
405x400x380 405x400x380 405x400x380 405x400x380 405x400x380 405x400x380 480x215x140
180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100
510x400x200 510x400x200 510x400x200 510x400x200 510x400x200 510x400x200 510x400x200
500x300x80 500x300x80 500x300x80 500x300x80 490x230x60 490x230x60 490x230x60 490x230x60
445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18
345x220x130 345x220x130 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40
340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 180x160x100 180x160x100
340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 280x230x180 580x260x255
340x240x170 340x240x170 340x240x170 235x155x70 235x155x70 235x155x70 500x300x80 500x300x80
295x190x170 295x190x170 580x235x200 280x155x115 160x94x50 160x94x50 580x235x200 580x235x200
250x150x90 250x150x90 310x230x70 310x230x70 390x330x210 390x330x210 400x340x210 410x360x210
410x360x115 410x360x115 410x360x115 410x360x115 470x390x120 470x390x120 235x155x70 105x57x27
260x155x105 260x155x105 260x155x105 340x280x190 340x280x190 340x280x190 260x230x230 425x230x52
540x230x160 260x155x105 260x155x100 260x155x105 280x155x115 260x215x170 490x330x90 298x241x216
473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 310x300x210 290x210x160
185x165x100 185x165x100 180x160x100 180x160x100 585x285x200 270x240x160 270x240x160 270x240x160
240x185x180 280x200x185 220x210x180 220x210x180 165x140x130 310x180x100 500x370x120 410x260x110
450x290x250 450x290x250 345x220x130 345x220x130 345x220x130 195x195x195 195x195x195 195x195x195
460x310x310 185x165x100 185x165x100 185x165x100 185x165x100 250x200x135 250x200x135 250x200x135
405x400x380 405x400x380 405x400x380 340x280x190 340x280x190 340x280x190 340x280x190 340x280x190
270x240x160 270x240x160 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
490x330x90 490x330x90 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 365x305x280
390x365x273 375x365x215 295x190x170 295x190x170 580x235x200 160x94x50 160x94x50 160x94x50 160x94x50
145x75x60 145x75x60 145x75x60 145x75x60 145x75x60 145x75x60 145x75x60 145x75x60 145x75x60 145x75x60
240x225x160 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53
470x180x103 470x180x103 470x180x103 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40
330x190x100 330x190x100 340x280x120 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50
490x330x90 490x330x90 520x330x200 180x160x100 180x160x100 280x230x180 280x230x180 280x230x180 390x230x140
425x320x300 380x260x75 340x280x190 340x280x190 340x280x120 340x280x120 520x330x200 345x220x130 480x210x190
230x90x20 230x90x20 230x90x20 230x90x20 230x90x20 230x90x20 215x158x155 215x158x155 215x158x155 150x150x65
298x241x216 260x215x170 250x150x90 260x160x160 260x160x160 520x330x200 260x155x105 260x155x105 340x280x120
473x323x283 473x323x283 473x323x283 430x300x200 430x300x200 553x261x152 310x300x210 390x285x140 430x135x135
450x290x250 430x135x135 430x135x135 185x165x100 185x165x100 185x165x100 220x220x220 220x220x220 220x220x220
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 360x340x170
220x210x180 260x155x105 340x280x120 340x280x120 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40
390x285x140 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 260x205x135 280x230x180 580x260x255
470x180x103 470x180x103 470x180x103 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 280x230x180
182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 445x205x120 280x230x180 520x330x200 390x285x140
390x285x140 390x285x140 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 260x200x165 430x135x135 430x135x135
260x200x165 260x200x165 390x285x140 390x285x140 430x135x135 250x150x90 310x230x70 300x245x70 300x245x70 240x225x160
430x300x200 430x300x200 430x300x200 430x300x200 430x300x200 430x300x200 430x300x200 420x180x75 420x180x75 420x180x75
260x215x170 490x330x90 390x230x140 500x300x80 365x305x280 180x160x100 425x230x52 520x330x200 340x280x120 430x135x135
450x290x250 245x235x155 245x235x155 340x280x190 270x240x160 270x240x160 480x215x140 480x215x140 380x260x75 380x260x75
425x320x300 390x285x140 390x230x140 390x230x140 390x230x140 380x280x65 345x205x145 345x205x145 345x205x145 390x380x170
375x365x215 380x260x75 245x235x155 580x260x255 580x260x255 298x241x216 298x241x216 349x201x172 368x254x171 410x343x110
349x201x172 430x360x242 368x254x171 185x165x100 180x160x100 180x160x100 390x285x140 375x150x100 380x280x65 240x225x160
425x320x300 380x280x65 345x205x145 345x205x145 250x65x65 250x65x65 250x65x65 250x65x65 250x65x65 250x65x65 185x140x138
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
510x330x260 510x330x260 370x350x340 370x350x340 390x380x170 390x380x170 250x200x135 250x200x135 250x200x135 250x200x135
465x395x255 465x395x255 465x395x255 465x395x255 465x395x255 465x395x255 465x395x255 465x395x255 465x395x255 465x395x255
195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195
490x330x90 490x330x90 390x285x140 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 280x230x180 580x260x255
390x365x273 340x240x170 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 415x390x315 415x390x315
490x330x90 490x330x90 490x330x90 490x330x90 260x230x160 340x280x190 340x280x190 340x280x190 330x240x160 185x165x100 185x165x100
260x215x170 345x205x145 345x205x145 380x280x65 250x150x90 250x150x90 250x150x90 185x165x100 185x165x100 180x160x100 180x160x100
380x260x75 380x260x75 380x260x75 430x135x135 430x135x135 390x285x140 390x285x140 250x200x135 250x200x135 260x210x160 260x210x160
330x190x100 330x190x100 260x200x165 260x200x165 180x160x100 180x160x100 180x160x100 180x160x100 260x160x160 260x160x160 130x90x80
473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 473x323x283 430x300x200
520x375x320 520x375x320 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90
295x190x170 295x190x170 165x60x60 165x60x60 165x60x60 165x60x60 165x60x60 165x60x60 160x94x50 160x94x50 160x94x50 160x94x50 240x225x160
185x140x138 185x140x138 485x400x255 220x105x75 330x190x100 250x150x90 490x330x90 490x330x90 310x230x70 310x230x70 310x230x70 340x280x120
310x300x225 130x65x65 130x65x65 130x65x65 130x65x65 130x65x65 130x65x65 490x330x90 490x330x90 490x330x90 490x330x90 390x230x140 390x230x140
500x300x80 490x330x90 380x260x75 430x135x135 220x105x75 185x165x100 185x165x100 330x240x160 340x280x190 260x155x105 260x155x105 340x280x120
553x261x152 330x190x100 190x190x120 490x330x90 490x330x90 490x330x90 260x230x160 250x205x140 390x285x140 260x155x105 340x280x120 340x280x120
330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 390x280x135 390x280x135 390x280x135 390x195x45 390x195x45
385x290x150 375x365x215 372x365x219 585x285x200 298x286x260 318x318x260 318x318x260 298x241x216 298x241x216 345x220x130 345x220x130 450x255x55
540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160
450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250
410x360x115 410x360x115 410x360x115 410x360x115 410x360x115 410x360x115 410x360x115 410x360x115 410x360x115 298x286x260 318x318x260 317x317x260
515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265
310x300x225 298x286x260 318x318x260 240x225x160 260x215x170 390x285x140 345x205x145 345x205x145 185x165x100 245x235x155 340x280x190 260x155x100
405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195
220x105x75 310x230x70 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 230x53x53 245x235x155 430x135x135 430x135x135
260x230x160 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 490x330x90 380x260x75 345x220x130 185x165x100 440x190x190 400x370x330
470x245x210 470x245x210 535x400x180 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 445x205x120 520x330x200 390x140x80 390x140x80
450x90x30 480x215x140 450x320x200 185x165x100 420x170x85 420x170x85 260x155x105 390x230x140 180x180x115 365x305x280 445x205x120 230x182x170 245x235x155
370x350x340 310x300x225 390x340x210 260x160x160 330x240x160 380x260x75 340x280x190 410x270x150 490x330x90 490x330x90 260x210x160 260x230x160 310x230x70
553x261x152 490x330x90 490x330x90 260x210x160 260x230x160 250x205x140 250x205x140 340x280x120 260x205x135 270x240x160 270x240x160 185x140x138 215x158x155
255x190x175 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105
515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 375x245x235
370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340 370x350x340
295x190x170 295x190x170 580x235x200 165x60x60 165x60x60 165x60x60 165x60x60 165x60x60 165x60x60 160x94x50 160x94x50 160x94x50 160x94x50 240x225x160 580x235x200
390x365x273 220x210x180 220x210x180 220x210x180 220x210x180 220x210x180 220x210x180 220x210x180 220x210x180 375x365x215 580x235x200 153x64x64 153x64x64 153x64x64
270x240x160 270x240x160 470x180x103 470x180x103 470x180x103 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 180x160x100 180x160x100 580x260x255
345x220x130 345x220x130 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 365x305x280 190x190x120 190x190x120 280x230x180 280x230x180 390x230x140
375x365x215 390x340x210 553x261x152 349x201x172 195x150x114 260x200x165 260x200x165 380x260x75 380x260x75 380x260x75 380x260x75 250x205x140 390x230x140 390x230x140
405x400x380 405x400x380 405x400x380 405x400x380 370x350x340 370x350x340 480x215x140 480x215x140 480x215x140 130x90x80 130x90x80 130x90x80 130x90x80 130x80x15 130x80x15
185x185x185 185x185x185 185x185x185 185x185x185 185x185x185 185x185x185 210x210x210 210x210x210 210x210x210 210x210x210 210x210x210 210x210x210 210x210x210 210x210x210
390x365x273 390x365x273 390x365x273 575x360x310 340x240x170 340x240x170 340x240x170 340x240x170 560x310x280 560x310x280 560x310x280 560x310x280 530x385x250 415x390x315
380x285x280 470x245x210 470x245x210 470x245x210 245x235x155 425x230x52 390x380x170 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 490x330x90 490x330x90
270x240x160 270x240x160 470x180x103 470x180x103 470x180x103 390x285x140 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 260x205x135 260x205x135 280x230x180
490x330x90 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 270x240x160 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35
280x180x95 280x180x95 280x180x95 280x180x95 368x254x171 349x201x172 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35 160x150x35
340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170 340x240x170
250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x80x65 250x80x65 250x200x135 250x200x135 250x200x135 250x200x135 250x80x65 250x80x65 250x80x65 250x80x65
380x260x75 260x230x160 340x280x190 260x155x105 310x230x70 410x270x150 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 440x190x190 220x200x80 220x200x80 220x200x80
320x290x160 425x230x52 180x160x100 500x240x40 500x240x40 500x240x40 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 380x260x75 340x280x190 345x220x130 520x330x200
490x330x90 490x330x90 490x330x90 490x330x90 520x330x200 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 180x160x100 180x160x100 280x230x180 280x230x180 580x260x255
425x230x52 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 270x240x160 330x190x100 345x220x130 345x220x130 490x330x90 260x210x160 260x230x160
310x300x225 310x300x225 310x300x225 310x300x225 310x300x225 500x300x80 500x300x80 500x300x80 490x230x60 490x230x60 490x330x90 490x330x90 490x330x90 490x330x90 260x215x170 260x215x170
390x365x273 390x365x273 390x365x273 340x240x170 560x310x280 560x310x280 560x310x280 560x310x280 445x205x18 445x205x18 445x205x18 340x180x180 340x180x180 340x180x180 415x390x315 580x235x200
390x365x273 390x365x273 390x365x273 400x400x300 340x240x170 445x205x18 340x180x180 530x385x250 415x390x315 390x290x95 260x155x120 260x155x120 260x155x120 260x155x120 260x155x120 260x155x120
380x260x75 490x330x90 345x220x130 520x330x200 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 245x235x155 340x280x120 425x230x52 270x240x160 270x240x160
260x155x105 260x155x105 340x280x190 340x280x190 430x135x135 430x135x135 445x205x120 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 490x330x90 490x330x90
390x358x265 340x240x170 207x147x115 207x147x115 207x147x115 235x155x70 235x155x70 520x330x200 310x230x70 310x230x70 310x230x70 445x205x120 295x190x170 295x190x170 280x155x115 240x225x160 240x225x160
340x240x170 430x135x135 430x135x135 270x240x160 270x240x160 270x240x160 425x230x52 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 260x160x160 345x220x130 260x230x160
540x230x160 540x230x160 540x230x160 360x340x170 360x340x170 360x340x170 360x340x170 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 210x148x100 210x148x100 210x148x100 320x140x70 320x140x70
520x350x315 520x350x315 380x200x150 185x165x100 260x200x165 390x285x140 520x330x200 430x135x135 585x285x200 345x205x145 580x235x200 310x180x100 310x180x100 310x180x100 450x110x90 450x90x30 490x330x90 260x230x160
300x200x130 180x160x100 180x160x100 185x165x100 185x165x100 230x182x170 440x190x190 440x190x190 260x155x105 260x155x105 340x280x120 340x280x120 340x280x190 330x190x100 330x190x100 345x220x130 130x90x80 130x90x80
385x290x150 385x290x150 450x290x250 450x290x250 405x400x380 600x400x290 600x400x290 375x245x235 330x190x100 330x190x100 390x280x135 480x215x140 480x215x140 480x215x140 250x150x90 250x150x90 240x225x160 240x225x160
325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100
460x335x185 460x335x185 280x200x185 280x200x185 280x200x185 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 520x330x200 580x235x200 240x225x160
580x380x270 580x380x270 580x380x270 580x380x270 580x380x270 580x380x270 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240 325x310x240
460x335x185 460x335x185 460x335x185 460x335x185 380x260x75 380x260x75 490x330x90 490x330x90 520x330x200 345x205x145 305x205x25 305x205x25 305x205x25 305x205x25 305x205x25 305x205x25 245x235x155 230x182x170 340x280x190
470x180x103 470x180x103 470x180x103 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 190x190x120 180x160x100 180x160x100 280x230x180
405x280x195 280x200x185 280x200x185 280x200x185 280x200x185 580x235x200 185x185x105 185x185x105 185x185x105 185x185x105 580x235x200 185x185x105 185x185x105 185x185x105 185x185x105 435x240x47 435x240x47 435x240x47 435x240x47
560x310x280 560x310x280 560x310x280 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 530x385x250 530x385x250 530x385x250 530x385x250 415x390x315 580x235x200
460x335x185 390x340x210 390x340x210 390x340x210 390x340x210 250x205x140 235x68x68 235x68x68 235x68x68 235x68x68 570x220x35 570x220x35 570x220x35 570x220x35 450x320x200 400x180x110 400x180x110 390x290x95 299x280x31 299x280x31 450x310x38
540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160
515x400x265 390x340x210 430x360x242 485x400x255 485x400x255 255x190x175 440x350x280 410x270x150 390x230x140 345x205x145 390x380x170 185x185x105 185x185x105 185x185x105 185x185x105 298x286x260 318x318x260 317x317x260 298x241x216 298x241x216
380x260x75 380x260x75 380x260x75 260x210x160 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 490x330x90 490x330x90 270x240x160 270x240x160 260x160x160 340x280x120 340x280x190 340x280x190 230x210x120 270x210x100 440x190x190
370x350x340 270x210x100 490x330x90 380x260x75 260x210x160 260x230x160 250x205x140 400x250x45 400x250x45 400x250x45 345x205x145 310x230x70 390x285x140 520x330x200 245x235x155 250x200x135 260x155x105 340x280x120 340x280x120 145x75x60 300x220x210
260x230x160 490x330x90 260x155x105 260x155x105 340x280x190 340x280x190 260x205x135 230x210x120 195x140x35 195x140x35 195x140x35 195x140x35 450x110x90 450x110x90 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 250x205x140 585x285x200
260x210x160 260x210x160 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 160x160x60 260x230x160 260x230x160 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 340x280x190 340x280x190 340x280x190 340x280x190 340x280x120 340x280x120
575x360x310 340x240x170 340x240x170 340x240x170 560x310x280 560x310x280 560x310x280 560x310x280 560x310x280 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 580x235x200 470x380x80 470x380x80 470x380x80 470x380x80
430x300x200 575x325x265 420x180x75 420x180x75 185x165x100 260x200x165 260x160x160 330x240x160 490x330x90 490x330x90 380x260x75 380x260x75 270x240x160 270x240x160 365x305x280 480x215x140 345x220x130 250x200x135 250x205x140 240x225x160 425x230x52 310x230x70
100x80x80 100x80x80 310x230x70 310x230x70 345x220x130 260x220x120 180x160x100 180x160x100 180x160x100 450x255x55 450x255x55 340x280x120 185x165x100 185x165x100 260x230x160 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 440x190x190 245x235x155
580x390x390 580x390x390 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220
260x155x100 260x155x100 260x155x100 260x155x100 260x155x100 260x155x100 260x155x100 260x155x100 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105
85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42 85x50x42
590x270x240 330x190x100 340x280x190 340x280x190 345x220x130 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 310x230x70 310x230x70 185x165x100 425x230x52 270x240x160 520x330x200 445x205x120 410x270x150 390x230x140 345x205x145 345x205x145 400x370x330 585x285x200
505x335x310 390x285x140 345x220x130 345x220x130 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 340x110x40 260x205x135 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 195x195x195 190x190x120 180x160x100 180x160x100 180x160x100 180x160x100 390x230x140 580x260x255
540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160
530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250 530x385x250
515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265 515x400x265
180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 290x210x160 290x210x160 290x210x160 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 250x205x140 250x205x140
380x260x75 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 340x280x190 180x160x100 480x205x110 480x205x110 480x205x110 480x205x110 330x190x100 177x55x55 177x55x55 177x55x55 177x55x55 177x55x55 177x55x55 390x380x170 270x240x160
575x325x265 390x260x85 390x260x85 390x260x85 390x260x85 240x185x180 280x200x185 220x210x180 445x205x120 490x330x90 490x330x90 185x165x100 185x165x100 340x280x120 340x280x120 360x295x185 260x155x105 320x220x180 130x90x80 345x220x130 345x220x130 280x160x120 330x190x100 330x190x100 220x105x75 430x135x135 430x135x135 255x190x175
380x260x75 380x260x75 490x330x90 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 160x160x70 260x155x105 260x155x105 330x190x100 340x280x190 340x280x190 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 440x20x10 440x20x10 440x20x10 440x20x10 440x20x10 440x20x10 425x230x52 390x230x140 330x240x70 330x240x70
575x360x310 580x390x280 560x310x280 560x310x280 560x310x280 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 445x205x18 340x180x180 340x180x180 340x180x180 340x180x180 600x400x120 600x400x120 600x400x120 600x400x120 600x400x120 390x290x95 580x235x200
460x335x185 460x335x185 490x330x90 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 400x370x330 480x215x140
340x240x170 585x210x205 360x340x170 430x360x242 430x360x242 485x400x255 485x400x255 430x360x242 553x261x152 440x190x190 270x210x100 490x330x90 380x260x75 250x205x140 345x205x145 430x135x135 310x230x70 190x190x120 185x165x100 260x200x165 180x160x100 260x160x160 390x285x140 520x330x200 270x240x160 245x235x155 390x380x170 250x200x135 260x155x105
490x330x90 490x330x90 380x260x75 380x260x75 380x260x75 260x230x160 260x230x160 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 182x110x50 180x160x100 310x230x70 310x230x70 130x90x80 130x90x80 425x230x52 580x235x200 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 445x205x120 520x330x200 440x190x190
280x200x185 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 127x127x127 340x280x190 320x220x180 240x225x160 240x225x160 330x330x180
405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 405x280x195 255x190x175
370x350x340 360x340x170 575x325x265 390x340x210 185x165x100 185x165x100 185x165x100 185x165x100 260x200x165 260x200x165 260x200x165 260x200x165 260x160x160 260x160x160 260x160x160 260x160x160 330x240x160 330x240x160 330x240x160 330x240x160 340x280x190 340x280x190 340x280x120 340x280x120 340x280x120 340x280x120 580x260x255 580x260x255 390x330x210 390x330x210
515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260 470x390x260
505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 520x330x200 470x180x103 270x210x70 270x210x70 270x210x70 270x210x70 270x210x70
425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 425x305x235 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 420x345x110 410x285x110
505x335x310 505x335x310 505x335x310 505x335x310 505x335x310 530x400x320 530x400x320 530x400x320 260x205x135 260x205x135 260x205x135 260x205x135 260x205x135 390x285x140 390x285x140 390x140x80 390x140x80 390x140x80 390x140x80 390x140x80 520x330x200 470x180x103 470x180x103 470x180x103 470x180x103 470x180x103 280x230x180 280x230x180 280x230x180 270x210x70 298x241x216 298x241x216 298x241x216
380x260x75 380x260x75 260x230x160 260x155x105 260x155x105 310x230x70 345x220x130 260x160x160 180x160x100 180x160x100 185x165x100 185x165x100 440x190x190 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 195x140x35 410x270x150 245x235x155 260x205x135 430x135x135 430x135x135 320x220x180
175x160x100 175x160x100 580x380x270 450x290x250 450x290x250 450x290x250 450x290x250 450x290x250 570x295x180 380x285x280 380x285x280 380x285x280 380x285x280 380x285x280 130x90x80 130x90x80 130x90x80 130x90x80 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165
460x310x310 145x75x60 145x75x60 145x75x60 220x105x75 260x200x165 185x165x100 260x200x165 180x160x100 330x240x160 490x330x90 380x260x75 260x210x160 260x230x160 250x205x140 390x285x140 430x135x135 310x230x70 345x220x130 250x200x135 130x90x80 305x180x75 305x180x75 305x180x75 305x180x75 305x180x75 305x180x75 195x195x180 195x195x180 195x195x180 195x195x180 340x280x190 340x280x120 340x280x120 320x220x180 380x280x65 215x205x105 215x205x105 390x380x170
470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 470x200x110 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 460x280x135 450x90x30 450x90x30 450x90x30 450x90x30 450x90x30 440x80x5 440x80x5 450x102x93 450x102x93 450x102x93 450x102x93 450x102x93 438x80x10 438x80x10
370x350x340 220x105x75 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 315x315x100 315x315x100 260x200x165 260x200x165 260x200x165 180x160x100 180x160x100 330x240x160 330x240x160 490x330x90 490x330x90 390x285x140 390x285x140 270x240x160 270x240x160 270x240x160 245x235x155 430x135x135 430x135x135 310x230x70 310x230x70 310x230x70 250x200x135 250x200x135 130x90x80 440x190x190 440x190x190 260x155x105 260x155x105 360x295x185 295x190x170 298x241x216 298x241x216
340x240x170 340x240x170 340x240x170 470x255x74 470x255x74 470x255x74 470x255x74 320x290x160 260x215x170 185x165x100 185x165x100 185x165x100 185x165x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 180x160x100 330x240x160 330x240x160 290x210x160 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 380x260x75 390x285x140 390x285x140 245x235x155 430x135x135 260x155x105 260x155x105 340x280x120 340x280x120 320x220x180 360x295x185 368x254x171 260x230x160 260x230x160 260x230x160 250x205x140 250x205x140
415x390x315 415x390x315 415x390x315 415x390x315 415x390x315 415x390x315 415x390x315 415x390x315 415x390x315 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 445x260x185 405x365x340 405x365x340 405x365x340 405x365x340 435x240x47 435x240x47 435x240x47 435x240x47 435x240x47 435x240x47 435x240x47 435x240x47
340x240x170 460x310x310 585x210x205 370x350x340 370x350x340 370x350x340 575x325x265 298x241x216 185x140x138 295x190x170 270x210x100 440x190x190 260x200x165 490x330x90 490x330x90 490x330x90 490x330x90 490x330x90 380x260x75 380x260x75 380x260x75 380x260x75 260x230x160 260x230x160 250x205x140 250x205x140 390x230x140 345x205x145 345x220x130 130x90x80 310x230x70 310x230x70 220x105x75 185x165x100 260x200x165 180x160x100 180x160x100 260x160x160 330x240x160 390x285x140 390x285x140 520x330x200 270x240x160 270x240x160 390x380x170 390x380x170 425x230x52 250x200x135 250x200x135 260x155x105 340x280x120 340x280x120 340x280x120 320x220x180
590x370x320 590x370x320 405x365x340 553x261x152 432x168x130 432x168x130 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 250x150x90 240x100x30 240x100x30 240x100x30 240x100x30 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 330x190x100 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40 190x180x40 185x165x100 185x165x100 185x165x100 185x165x100 160x160x40 160x160x40 490x330x90 490x330x90 490x330x90 490x330x90
390x340x210 390x340x210 240x185x180 240x185x180 280x200x185 280x200x185 460x310x310 575x325x265 553x261x152 450x255x55 330x330x180 240x225x160 280x155x115 280x155x115 580x235x200 380x260x75 380x260x75 380x260x75 380x260x75 260x210x160 260x210x160 345x220x130 430x135x135 430x135x135 250x150x90 375x150x100 375x150x100 260x215x170 260x215x170 185x165x100 260x200x165 180x160x100 180x160x100 260x160x160 245x235x155 250x200x135 250x200x135 250x200x135 250x200x135 340x280x190 360x295x185 320x220x180 490x330x90 490x330x90 260x230x160 260x230x160 445x205x120 250x205x140 250x205x140 250x205x140 250x205x140 190x190x120 190x190x120 390x285x140 390x285x140 270x240x160 270x240x160 270x240x160
510x330x260 425x320x300 505x335x310 440x180x70 440x180x70 310x230x70 345x220x130 345x220x130 345x220x130 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 250x200x135 305x180x75 305x180x75 195x195x180 195x195x180 195x195x180 260x155x100 260x155x100 260x155x100 260x155x100 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x120 260x155x120 260x155x120 260x155x120 340x280x120 340x280x120 340x280x120 340x280x120 340x280x120 340x280x120 280x230x180 280x230x180 380x280x65 195x195x195 195x195x195 195x195x195 215x205x105 215x205x105 580x235x200 580x235x200 425x230x52 425x230x52 425x230x52 425x230x52 105x57x27 105x57x27 105x57x27 298x286x260 298x286x260 298x286x260 318x318x260 318x318x260 317x317x260 317x317x260
465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113
390x390x375 440x360x330 450x290x250 405x400x380 405x365x340 560x310x280 585x210x205 585x210x205 365x343x206 365x343x206 500x355x315 500x355x315 500x355x315 495x355x315 495x355x315 495x355x315 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 290x210x120 515x400x265 515x400x265 340x280x120 340x280x120 340x280x120 340x280x120 375x245x235
460x202x195 460x330x200 470x200x110 340x180x180 340x180x180 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 440x360x330 575x360x310 575x360x310 575x360x310 450x290x250 450x290x250 298x286x260 317x317x260 317x317x260 450x255x55 450x255x55 450x255x55 450x255x55 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x230x160 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 260x200x165 185x165x100 185x165x100 185x165x100 185x165x100 330x240x160 330x240x70 180x160x100 180x160x100 180x160x100 180x160x100 245x235x155 245x235x155 245x235x155 245x235x155 320x290x160 320x290x160 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x100 260x155x100 260x155x100 260x155x100 260x155x100 256x151x10 256x151x10 256x151x10 256x151x10 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 260x155x105 250x150x90 250x150x90 250x150x90 250x150x90 330x190x100 330x190x100 330x190x100
540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160 540x230x160
465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27 385x155x27
500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300 500x350x300
465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 465x225x113 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 390x340x210 560x310x280 560x310x280 560x310x280 415x390x315 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 460x335x185 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 515x335x310 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 410x255x190 295x190x170 460x360x50 460x360x50 460x360x50 460x360x50 460x360x50 460x360x50 460x360x50 460x360x50 345x220x130 345x220x130 580x260x255 580x260x255 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220 220x220x220