 
     if (active)
         {
-        // load in the length of the neighbor list (MEM_TRANSFER: 4 bytes)
+        // load in the length of the neighbor list
         unsigned int n_neigh = d_n_neigh[idx];
 
         // read in the position of our particle.
-        // (MEM TRANSFER: 16 bytes)
         Scalar4 postypei = __ldg(d_pos + idx);
         Scalar3 posi = make_scalar3(postypei.x, postypei.y, postypei.z);
 
-        Scalar di;
+        Scalar di = Scalar(0);
         if (evaluator::needsDiameter())
             di = __ldg(d_diameter + idx);
-        else
-            di += Scalar(1.0); // shut up compiler warning
-        Scalar qi;
+
+        Scalar qi = Scalar(0);
         if (evaluator::needsCharge())
             qi = __ldg(d_charge + idx);
-        else
-            qi += Scalar(1.0); // shut up compiler warning
 
         unsigned int my_head = d_head_list[idx];
         unsigned int cur_j = 0;

    force.z = reducer.Sum(force.z);
    force.w = reducer.Sum(force.w);

    // now that the force calculation is complete, write out the result (MEM TRANSFER: 20 bytes)
    if (active && threadIdx.x % tpp == 0)
        d_force[idx] = force;


        for (int neigh_idx = threadIdx.x%tpp; neigh_idx < n_neigh; neigh_idx+=tpp)
            {
                {
                // read the current neighbor index
                cur_j = next_j;
                if (neigh_idx+tpp < n_neigh)
                    {
                    next_j = __ldg(d_nlist + my_head + neigh_idx+tpp);
                    }
                // get the neighbor's position
                Scalar4 postypej = __ldg(d_pos + cur_j);
                Scalar3 posj = make_scalar3(postypej.x, postypej.y, postypej.z);

                Scalar dj = Scalar(0.0);
                if (evaluator::needsDiameter())
                    dj = __ldg(d_diameter + cur_j);

                Scalar qj = Scalar(0.0);
                if (evaluator::needsCharge())
                    qj = __ldg(d_charge + cur_j);

                // calculate dr (with periodic boundary conditions)
                Scalar3 dx = posi - posj;

                // apply periodic boundary conditions
                dx = box.minImage(dx);

                // calculate r squared
                Scalar rsq = dot(dx, dx);

                // access the per type pair parameters
