Different results on 32bit and 64bit system

I am trying to calculate magnetostatic problem in the b-conforming
formulation, my problem is defined as follows:

[code]

mesh = Mesh("coilshield2.xml")
subdomains = MeshFunction("uint", mesh, "coilshield2_mat.xml")

PN = FunctionSpace(mesh, "Nedelec 1st kind H(curl)", 1)

v0 = TestFunction(PN)
u0 = TrialFunction(PN)

# Define functions
zero = Expression(("0.0", "0.0", "0.0"), degree=1)

# Dirichlet boundary
class DirichletBoundary(SubDomain):
    def inside(self, x, on_boundary):
        return on_boundary

# Boundary condition
bc = DirichletBC(PN, zero, DirichletBoundary())

class CurrentExpression0(Expression):
    def eval_data(self, value, data):
        if subdomains[data.cell().index()] == 1:
            value[0] = -data.x()[1]
            value[1] = data.x()[0]
            value[2] = 0.0
        else:
            value[0] = 0.0
            value[1] = 0.0
            value[2] = 0.0

    def dim(self):
        return 3

J = CurrentExpression0()

class MuExpression0(Expression):
    def eval_data(self, value, data):
        mu0 = 4*pi*1e-7
        if subdomains[data.cell().index()] == 2:
            value[0] = mu0*200
        else:
            value[0] = mu0

    def dim(self):
        return 0

Mu = MuExpression0()

a = inner(curl(v0), curl(u0))/Mu*dx
L = -inner(J, v0)*dx

problem = VariationalProblem(a, L, bc)
u = problem.solve()
plot(curl(u))

[/code]

When solving this system on my "atom" netbook with
32bit version of ubuntu 10.10 with dolfin 9.8, I get
a reasonable result.

Problem is, that on 64bit version of
the same software (core 2 duo processor) the result
looks like vectors pointing in random directions and
is definitely wrong

I use packages from ubuntu repositories, PETSc LU solver, umfpack.
Do you know, what could be the reason for this behavior?

Best regards
Stepan