Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision 207b496c369aa4d1d71645a349db9d309b33d5a8)
+++ src/GenPoly/Lvalue.cc	(revision ba89e9b755ab2625af2a9f8d4c886abb858a11ac)
@@ -17,4 +17,5 @@
 #include <string>                        // for string
 
+#include "Common/Debug.h"
 #include "Common/PassVisitor.h"
 #include "GenPoly.h"                     // for isPolyType
@@ -123,11 +124,19 @@
 		PassVisitor<AddrRef> addrRef;
 		PassVisitor<FixIntrinsicResult> intrinsicResults;
+		Debug::codeGen( translationUnit, "begin" );
 		mutateAll( translationUnit, intrinsicResults );
+		Debug::codeGen( translationUnit, "intrinsicResults" );
 		mutateAll( translationUnit, addrRef );
+		Debug::codeGen( translationUnit, "addrRef" );
 		mutateAll( translationUnit, refCvt );
+		Debug::codeGen( translationUnit, "refCvt" );
 		mutateAll( translationUnit, fixer );
+		Debug::codeGen( translationUnit, "fixer" );
 		mutateAll( translationUnit, collapser );
+		Debug::codeGen( translationUnit, "collapser" );
 		mutateAll( translationUnit, genLval );
+		Debug::codeGen( translationUnit, "genLval" );
 		mutateAll( translationUnit, elim );  // last because other passes need reference types to work
+		Debug::codeGen( translationUnit, "elim" );
 
 		// from this point forward, no other pass should create reference types.
@@ -363,4 +372,5 @@
 				for ( int i = 0; i < diff; ++i ) {
 					ret = mkDeref( ret );
+					// xxx - try removing one reference here? actually, looks like mkDeref already does this, so more closely look at the types generated.
 				}
 				if ( ! ResolvExpr::typesCompatibleIgnoreQualifiers( destType->stripReferences(), srcType->stripReferences(), SymTab::Indexer() ) ) {
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 207b496c369aa4d1d71645a349db9d309b33d5a8)
+++ src/InitTweak/InitTweak.cc	(revision ba89e9b755ab2625af2a9f8d4c886abb858a11ac)
@@ -520,4 +520,8 @@
 
 	ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
+		std::cerr << "=== createBitwiseAssignment ===" << std::endl;
+		std::cerr << "== dst: " << dst << std::endl;
+		std::cerr << "== src: " << src << std::endl;
+
 		static FunctionDecl * assign = nullptr;
 		if ( ! assign ) {
@@ -538,5 +542,9 @@
 				src = new AddressExpr( src );
 			}
-		}
+			// src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
+		}
+		std::cerr << "============= endl : " << std::endl;
+		std::cerr << "-- dst: " << dst << std::endl;
+		std::cerr << "-- src: " << src << std::endl;
 		return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
 	}
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision 207b496c369aa4d1d71645a349db9d309b33d5a8)
+++ src/ResolvExpr/CommonType.cc	(revision ba89e9b755ab2625af2a9f8d4c886abb858a11ac)
@@ -27,5 +27,5 @@
 #include "typeops.h"                     // for isFtype
 
-#define DEBUG
+// #define DEBUG
 #ifdef DEBUG
 #define PRINT(x) x
@@ -101,5 +101,5 @@
 			int diff = depth1-depth2;
 			// TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
-			if ( diff > 1 || diff < -1 ) return nullptr;
+			// if ( diff > 1 || diff < -1 ) return nullptr;
 
 			// special case where one type has a reference depth of 1 larger than the other