getting close to done

36 files changed, 20062 insertions, 2709 deletions

diff --git a/compiler_and_linker/unsorted/CABI.c b/compiler_and_linker/unsorted/CABI.c
index 3e99ca0..91883f5 100644
--- a/compiler_and_linker/unsorted/CABI.c
+++ b/compiler_and_linker/unsorted/CABI.c
@@ -1,11 +1,30 @@
 #include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
 #include "compiler/CMachine.h"
-#include "compiler/types.h"
+#include "compiler/CMangler.h"
+#include "compiler/CParser.h"
+#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
 #include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/types.h"
 
-static void *trans_vtboffsets; // TODO type
-static void *cabi_pathroot; // TODO type - 8 byte struct??
-static void *cabi_pathcur; // TODO type
+typedef struct OffsetList {
+    struct OffsetList *next;
+    SInt32 offset;
+} OffsetList;
+
+static OffsetList *trans_vtboffsets;
+static BClassList cabi_pathroot;
+static BClassList *cabi_pathcur;
 static TypeClass *cabi_loop_class;
 static Boolean cabi_loop_construct;
 
@@ -21,21 +40,271 @@ Type *CABI_GetPtrDiffTType(void) {
     return (Type *) &stsignedlong;
 }
 
-SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size) {}
+SInt16 CABI_StructSizeAlignValue(Type *type, SInt32 size) {
+    SInt16 align = CMach_GetTypeAlign(type);
+    if (align <= 1)
+        return 0;
+    else
+        return (align - 1) & (align - ((size & (align - 1))));
+}
+
+void CABI_ReverseBitField(TypeBitfield *tbitfield) {
+    UInt8 bits;
+    UInt8 a;
+    UInt8 b;
+
+    switch (tbitfield->bitfieldtype->size) {
+        case 1:
+            bits = 8;
+            break;
+        case 2:
+            bits = 16;
+            break;
+        case 4:
+            bits = 32;
+            break;
+        case 8:
+            bits = 64;
+            break;
+        default:
+            CError_FATAL(172);
+    }
+
+    b = tbitfield->unkB;
+    a = tbitfield->unkA;
+    tbitfield->unkA = (bits - a) - b;
+}
+
+static void CABI_AllocateZeroVTablePointer(void *unk, TypeClass *tclass) {
+    ClassList *base;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->is_virtual && base->base->vtable)
+            return;
+    }
+
+    tclass->size += void_ptr.size;
+}
+
+static SInt32 CABI_GetBaseSize(TypeClass *tclass) {
+    SInt32 size = tclass->size;
+
+    if (copts.vbase_abi_v2 && tclass->vbases)
+        return tclass->vbases->offset;
+
+    return size;
+}
+
+static void CABI_AllocateBases(DeclE *decle, TypeClass *tclass) {
+    Boolean flag;
+    TypeClass *baseclass;
+    ClassList *base;
+    VClassList *vbase;
+    SInt32 size;
+
+    flag = 0;
+    size = tclass->size;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->is_virtual) {
+            baseclass = base->base;
+            if (!(baseclass->flags & CLASS_FLAGS_1000)) {
+                base->offset = size + CMach_MemberAlignValue(TYPE(baseclass), size);
+                if (copts.vbase_abi_v2) {
+                    size = base->offset + CABI_GetBaseSize(baseclass);
+                } else {
+                    size = base->offset + baseclass->size;
+                    for (vbase = baseclass->vbases; vbase; vbase = vbase->next)
+                        size -= vbase->base->size;
+                }
+                flag = 0;
+            } else {
+                if (flag)
+                    base->offset = ++size;
+                else
+                    base->offset = size;
+                flag = 1;
+            }
+        }
+    }
+
+    tclass->size = size;
+}
+
+static void CABI_AllocateVirtualBasePointers(DeclE *decle, TypeClass *tclass) {
+    ClassList *base;
+    SInt32 size;
+
+    size = tclass->size;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->is_virtual) {
+            base->offset = size + CMach_MemberAlignValue(TYPE(&void_ptr), size);
+            size = base->offset + void_ptr.size;
+        }
+    }
+
+    tclass->size = size;
+}
 
-void CABI_ReverseBitField(TypeBitfield *tbitfield) {}
+static SInt32 CABI_GetMemberOffset(TypeClass *tclass, HashNameNode *name) {
+    ObjMemberVar *ivar;
 
-// not sure about the sig for this, it's unused lmao
-static void CABI_AllocateZeroVTablePointer() {}
+    if (!name)
+        return 0;
+
+    ivar = tclass->ivars;
+    while (1) {
+        if (ivar->name == name)
+            return ivar->offset;
+
+        if (!(ivar = ivar->next))
+            CError_FATAL(362);
+    }
+}
+
+static void CABI_AllocateMembers(DeclE *decle, TypeClass *tclass) {
+    ObjMemberVar *ivar;
+    SInt32 initialSize;
+    SInt32 maxSize;
+    TypeClass *unionClass;
+    SInt32 unionStart;
+    Boolean inAnonUnion;
+    Boolean removeNoNameIvars;
+
+    removeNoNameIvars = 0;
+    initialSize = maxSize = tclass->size;
+    CMach_StructLayoutInitOffset(maxSize);
+
+    unionClass = NULL;
+    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+        if (!ivar->anonunion) {
+            if (!(ivar->offset & 0x80000000)) {
+                if (tclass->mode == CLASS_MODE_1)
+                    CMach_StructLayoutInitOffset(initialSize);
+
+                if (IS_TYPE_BITFIELD(ivar->type))
+                    ivar->offset = CMach_StructLayoutBitfield(TYPE_BITFIELD(ivar->type), ivar->qual);
+                else
+                    ivar->offset = CMach_StructLayoutGetOffset(ivar->type, ivar->qual);
+
+                if (tclass->mode == CLASS_MODE_1) {
+                    SInt32 tmp = CMach_StructLayoutGetCurSize();
+                    if (tmp > maxSize)
+                        maxSize = tmp;
+                }
+
+                unionClass = NULL;
+            } else {
+                CError_ASSERT(412, unionClass);
+                ivar->offset = unionStart + CABI_GetMemberOffset(unionClass, ivar->name);
+                if (!inAnonUnion)
+                    ivar->anonunion = 1;
+                inAnonUnion = 0;
+            }
+
+            if (ivar->name == no_name_node || ivar->name == NULL)
+                removeNoNameIvars = 1;
+        } else {
+            CError_ASSERT(422, IS_TYPE_CLASS(ivar->type));
+
+            if (tclass->mode == CLASS_MODE_1)
+                CMach_StructLayoutInitOffset(initialSize);
+
+            unionStart = CMach_StructLayoutGetOffset(ivar->type, ivar->qual);
+            unionClass = TYPE_CLASS(ivar->type);
+            inAnonUnion = 1;
+
+            if (tclass->mode == CLASS_MODE_1) {
+                SInt32 tmp = CMach_StructLayoutGetCurSize();
+                if (tmp > maxSize)
+                    maxSize = tmp;
+            }
+
+            removeNoNameIvars = 1;
+        }
+
+        if (decle->vtable_ivar == ivar)
+            tclass->vtable->offset = ivar->offset;
+    }
+
+    if (removeNoNameIvars) {
+        ObjMemberVar **ptr = &tclass->ivars;
+        while (*ptr) {
+            if ((*ptr)->name == NULL || (*ptr)->name == no_name_node)
+                *ptr = (*ptr)->next;
+            else
+                ptr = &(*ptr)->next;
+        }
+    }
+
+    if (tclass->mode == CLASS_MODE_1)
+        tclass->size = maxSize;
+    else
+        tclass->size = CMach_StructLayoutGetCurSize();
+
+    if (copts.reverse_bitfields) {
+        for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+            if (IS_TYPE_BITFIELD(ivar->type))
+                CABI_ReverseBitField(TYPE_BITFIELD(ivar->type));
+        }
+    }
+}
+
+static void CABI_AllocateVirtualBases(DeclE *decle, TypeClass *tclass) {
+    VClassList *vbase;
+    SInt32 size;
+
+    size = tclass->size;
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        vbase->offset = size + CMach_MemberAlignValue(TYPE(vbase->base), size);
+        size = vbase->offset + CABI_GetBaseSize(vbase->base);
+
+        if (vbase->has_override)
+            size += CMach_MemberAlignValue(TYPE(&stunsignedlong), size) + 4;
+    }
+
+    tclass->size = size;
+}
 
-static SInt32 CABI_GetBaseSize(TypeClass *tclass) {}
-static void CABI_AllocateBases() {}
-static void CABI_AllocateVirtualBasePointers() {}
-static void CABI_GetMemberOffset() {}
-static void CABI_AllocateMembers() {}
-static void CABI_AllocateVirtualBases() {}
-static void CABI_FindZeroDeltaVPtr() {}
-static void CABI_FindZeroVirtualBaseMember() {}
+static Boolean CABI_FindZeroDeltaVPtr(TypeClass *tclass) {
+    ClassList *base;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->is_virtual && base->base->vtable && !base->offset) {
+            tclass->vtable->offset = base->base->vtable->offset;
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static Object *CABI_FindZeroVirtualBaseMember(TypeClass *tclass, Object *obj) {
+    NameSpaceObjectList *nsol;
+    ClassList *base;
+    Object *chk;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->is_virtual && !base->offset && !base->voffset && base->base->vtable) {
+            for (nsol = CScope_FindName(base->base->nspace, obj->name); nsol; nsol = nsol->next) {
+                chk = OBJECT(nsol->object);
+                if (
+                    chk->otype == OT_OBJECT &&
+                    chk->datatype == DVFUNC &&
+                    CClass_GetOverrideKind(TYPE_FUNC(chk->type), TYPE_FUNC(obj->type), 0) == 1
+                    )
+                    return chk;
+            }
+
+            if ((chk = CABI_FindZeroVirtualBaseMember(base->base, obj)))
+                return chk;
+        }
+    }
+
+    return NULL;
+}
 
 void CABI_AddVTable(TypeClass *tclass) {
     tclass->vtable = galloc(sizeof(VTable));
@@ -46,48 +315,1714 @@ SInt32 CABI_GetVTableOffset(TypeClass *tclass) {
     return 0;
 }
 
-static void CABI_GetBaseVTableSize() {}
-static void CABI_ApplyClassFlags() {}
-static void CABI_AllocateVTable() {}
-void CABI_LayoutClass(DeclE *decle, TypeClass *tclass) {}
-void CABI_MakeDefaultArgConstructor(TypeClass *tclass, Object *obj) {}
-static void CABI_ThisArg() {}
-ENode *CABI_MakeThisExpr(TypeClass *tclass, SInt32 offset) {}
-static void CABI_VArg() {}
-static void CABI_MakeVArgExpr() {}
-static void CABI_MakeCopyConArgExpr() {}
-static void CABI_InitVBasePtr1() {}
-static void CABI_InitVBasePtrs() {}
-static void CABI_GetVBasePath() {}
-static void CABI_GetVBasePtr() {}
-static SInt32 CABI_FindNVBase(TypeClass *tclass, TypeClass *base, SInt32 offset) {}
-SInt32 CABI_GetCtorOffsetOffset(TypeClass *tclass, TypeClass *base) {}
-static void CABI_InitVBaseCtorOffsets() {}
-static void CABI_InitVTablePtrs() {}
-static Boolean CABI_IsOperatorNew(Object *obj) {}
-Object *CABI_ConstructorCallsNew(TypeClass *tclass) {}
-void CABI_TransConstructor(Object *obj, Statement *stmt, TypeClass *tclass, TransConstructorCallback callback, Boolean flag) {}
-void CABI_MakeDefaultConstructor(TypeClass *tclass, Object *obj) {}
-static void CABI_AssignObject() {}
-static void CABI_FindIntegralSizeType() {}
-static void CABI_AppendCopyRegion() {}
-static void CABI_ClassInitLoopCallBack() {}
-static void CABI_CopyConAssignCB() {}
-void CABI_MakeDefaultCopyConstructor(TypeClass *tclass, Object *obj) {}
-void CABI_MakeDefaultAssignmentOperator(TypeClass *tclass, Object *obj) {}
-static void CABI_DestroyMembers() {}
-static void CABI_DestroyBases() {}
-static void CABI_DestroyVBases() {}
-void CABI_TransDestructor(Object *obj1, Object *obj2, Statement *stmt, TypeClass *tclass) {}
-void CABI_MakeDefaultDestructor(TypeClass *tclass, Object *obj) {}
-static void CABI_CreateLayeredDestructor() {}
-void CABI_MakeLayeredDestructor(TypeClass *tclass, Object *obj) {}
-
-Object *CABI_GetDestructorObject(Object *obj, int what) {
+static SInt32 CABI_GetBaseVTableSize(TypeClass *tclass) {
+    VClassList *vbase;
+    SInt32 size;
+
+    size = tclass->vtable->size;
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        if (vbase->base->vtable)
+            size -= CABI_GetBaseVTableSize(vbase->base);
+    }
+
+    return size;
+}
+
+static void CABI_ApplyClassFlags(Object *obj, UInt8 flags, Boolean unused) {
+    if (flags & CLASS_EFLAGS_INTERNAL)
+        obj->flags |= OBJECT_FLAGS_10;
+    if (flags & CLASS_EFLAGS_IMPORT)
+        obj->flags |= OBJECT_FLAGS_20;
+    if (flags & CLASS_EFLAGS_EXPORT)
+        obj->flags |= OBJECT_FLAGS_40;
+}
+
+static void CABI_AllocateVTable(DeclE *decle, TypeClass *tclass) {
+    SInt32 size;
+    ObjBase *objbase;
+    Object *obj;
+    ObjMemberVar *ivar;
+    ClassList *base;
+    VClassList *vbase;
+    int i;
+
+    size = 0;
+
+    if (!tclass->vtable) {
+        CABI_AddVTable(tclass);
+        decle->xA = decle->x8 - 1;
+    }
+
+    if (!CABI_FindZeroDeltaVPtr(tclass)) {
+        ivar = galloc(sizeof(ObjMemberVar));
+        memclrw(ivar, sizeof(ObjMemberVar));
+
+        ivar->otype = OT_MEMBERVAR;
+        ivar->access = ACCESSPUBLIC;
+        ivar->name = vptr_name_node;
+        ivar->type = TYPE(&void_ptr);
+        decle->vtable_ivar = ivar;
+
+        for (i = decle->xA; ; i--) {
+            if (i < 0) {
+                ivar->next = tclass->ivars;
+                tclass->ivars = ivar;
+                break;
+            }
+
+            CError_ASSERT(666, decle->objlist[i]);
+
+            if (decle->objlist[i]->otype == OT_MEMBERVAR) {
+                ivar->next = OBJ_MEMBER_VAR(decle->objlist[i])->next;
+                OBJ_MEMBER_VAR(decle->objlist[i])->next = ivar;
+                break;
+            }
+        }
+
+        if (tclass->flags & (CLASS_FLAGS_10 | CLASS_FLAGS_2000))
+            size = void_ptr.size;
+        else
+            size = 8;
+    } else {
+        decle->vtable_ivar = NULL;
+    }
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base->vtable && !base->is_virtual) {
+            base->voffset = size;
+            if (copts.vbase_abi_v2) {
+                size += CABI_GetBaseVTableSize(base->base);
+            } else {
+                size += base->base->vtable->size;
+                for (vbase = base->base->vbases; vbase; vbase = vbase->next) {
+                    if (vbase->base->vtable)
+                        size -= vbase->base->vtable->size;
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < decle->x8; i++) {
+        CError_ASSERT(714, objbase = decle->objlist[i]);
+
+        if (objbase->otype == OT_OBJECT && OBJECT(objbase)->datatype == DVFUNC) {
+            TypeMethod *tmethod = TYPE_METHOD(OBJECT(objbase)->type);
+            Object *baseobj = CABI_FindZeroVirtualBaseMember(tclass, OBJECT(objbase));
+
+            if (baseobj) {
+                tmethod->x1E = TYPE_METHOD(baseobj->type)->x1E;
+            } else {
+                tmethod->x1E = size;
+                size += 4;
+            }
+        }
+    }
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        if (vbase->base->vtable) {
+            vbase->voffset = size;
+            if (copts.vbase_abi_v2)
+                size += CABI_GetBaseVTableSize(vbase->base);
+            else
+                size += vbase->base->vtable->size;
+        }
+    }
+
+    obj = CParser_NewCompilerDefDataObject();
+    CABI_ApplyClassFlags(obj, tclass->eflags, 0);
+
+    obj->name = CMangler_VTableName(tclass);
+    obj->type = CDecl_NewStructType(size, 4);
+    obj->qual = Q_CONST;
+    obj->nspace = tclass->nspace;
+    switch (tclass->action) {
+        case CLASS_ACTION_0:
+            obj->sclass = TK_STATIC;
+            obj->qual |= Q_20000;
+            break;
+    }
+
+    CParser_UpdateObject(obj, NULL);
+
+    tclass->vtable->object = obj;
+    tclass->vtable->owner = tclass;
+    tclass->vtable->size = size;
+}
+
+void CABI_LayoutClass(DeclE *decle, TypeClass *tclass) {
+    char saveAlignMode = copts.align_mode;
+
+    tclass->size = 0;
+    if (!tclass->sominfo) {
+        if (tclass->bases)
+            CABI_AllocateBases(decle, tclass);
+        if (tclass->flags & CLASS_FLAGS_20)
+            CABI_AllocateVirtualBasePointers(decle, tclass);
+        if (decle->xC)
+            CABI_AllocateVTable(decle, tclass);
+        CABI_AllocateMembers(decle, tclass);
+        if (tclass->flags & CLASS_FLAGS_20)
+            CABI_AllocateVirtualBases(decle, tclass);
+    } else {
+        copts.align_mode = AlignMode2_PPC;
+        CABI_AllocateMembers(decle, tclass);
+    }
+
+    tclass->align = CMach_GetClassAlign(tclass);
+    if (tclass->size == 0) {
+        tclass->size = 1;
+        tclass->flags |= CLASS_FLAGS_1000;
+    } else {
+        tclass->size += CABI_StructSizeAlignValue(TYPE(tclass), tclass->size);
+    }
+
+    tclass->flags |= CLASS_FLAGS_2;
+
+    copts.align_mode = saveAlignMode;
+}
+
+void CABI_MakeDefaultArgConstructor(TypeClass *tclass, Object *func) {
+    DefArgCtorInfo *info;
+    Boolean saveDebugInfo;
+    ENodeList *copied;
+    FuncArg *args;
+    ENodeList *argexprs;
+    CScopeSave savedScope;
+    Statement firstStmt;
+    Statement returnStmt;
+
+    CError_FATAL(860);
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    CError_ASSERT(866, info = func->u.func.defargdata);
+
+    CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    if (tclass->flags & CLASS_FLAGS_20)
+        arguments->next->object->name = no_name_node;
+
+    firstStmt.next = &returnStmt;
+
+    memclrw(&returnStmt, sizeof(Statement));
+    returnStmt.type = ST_RETURN;
+    returnStmt.expr = lalloc(sizeof(ENode));
+    returnStmt.expr->type = EFUNCCALL;
+    returnStmt.expr->cost = 200;
+    returnStmt.expr->flags = 0;
+    returnStmt.expr->rtype = TYPE(&void_ptr);
+
+    returnStmt.expr->data.funccall.funcref = CExpr_MakeObjRefNode(info->default_func, 0);
+    returnStmt.expr->data.funccall.functype = TYPE_FUNC(info->default_func->type);
+    args = TYPE_FUNC(info->default_func->type)->args;
+    returnStmt.expr->data.funccall.args = lalloc(sizeof(ENodeList));
+    argexprs = returnStmt.expr->data.funccall.args;
+
+    argexprs->node = create_objectnode(arguments->object);
+
+    if (tclass->flags & CLASS_FLAGS_20) {
+        args = args->next;
+        argexprs->next = lalloc(sizeof(ENodeList));
+        argexprs = argexprs->next;
+        argexprs->node = create_objectnode(arguments->next->object);
+    }
+
+    args = args->next;
+    argexprs->next = lalloc(sizeof(ENodeList));
+    argexprs = argexprs->next;
+    argexprs->node = CInline_CopyExpression(info->default_arg, CopyMode0);
+
+    while ((args = args->next) && args->dexpr) {
+        argexprs->next = lalloc(sizeof(ENodeList));
+        argexprs = argexprs->next;
+        argexprs->node = CInline_CopyExpression(args->dexpr, CopyMode0);
+    }
+
+    argexprs->next = NULL;
+
+    CFunc_CodeCleanup(&firstStmt);
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+
+    func->u.func.defargdata = NULL;
+}
+
+static Object *CABI_ThisArg(void) {
+    CError_ASSERT(931, arguments && IS_TYPE_POINTER_ONLY(arguments->object->type));
+    return arguments->object;
+}
+
+ENode *CABI_MakeThisExpr(TypeClass *tclass, SInt32 offset) {
+    ENode *expr;
+
+    if (tclass) {
+        if (!tclass->sominfo) {
+            expr = create_objectnode(CABI_ThisArg());
+            if (tclass->flags & CLASS_FLAGS_1)
+                expr = makemonadicnode(expr, EINDIRECT);
+        } else {
+            expr = CSOM_SOMSelfObjectExpr(tclass);
+        }
+    } else {
+        expr = create_objectnode(CABI_ThisArg());
+        expr->rtype = TYPE(&void_ptr);
+    }
+
+    if (offset)
+        expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+
+    return expr;
+}
+
+static Object *CABI_VArg(void) {
+    CError_ASSERT(976, arguments && arguments->next && IS_TYPE_INT(arguments->next->object->type));
+    return arguments->next->object;
+}
+
+static ENode *CABI_MakeVArgExpr(void) {
+    return create_objectnode(CABI_VArg());
+}
+
+static ENode *CABI_MakeCopyConArgExpr(TypeClass *tclass, Boolean flag) {
+    ObjectList *args;
+
+    CError_ASSERT(1000, args = arguments);
+    CError_ASSERT(1001, args = args->next);
+    if (flag && (tclass->flags & CLASS_FLAGS_20))
+        CError_ASSERT(1002, args = args->next);
+    CError_ASSERT(1003, IS_TYPE_POINTER_ONLY(args->object->type));
+
+    return create_objectnode(args->object);
+}
+
+static ENode *CABI_InitVBasePtr1(ENode *expr, TypeClass *tclass1, TypeClass *tclass2, TypeClass *tclass3, SInt32 offset) {
+    ClassList *base;
+    SInt32 newOffset;
+    OffsetList *list;
+
+    for (base = tclass2->bases; base; base = base->next) {
+        if (base->base == tclass3 && base->is_virtual) {
+            newOffset = offset + base->offset;
+
+            for (list = trans_vtboffsets; list; list = list->next) {
+                if (newOffset == list->offset)
+                    break;
+            }
+
+            if (!list) {
+                list = lalloc(sizeof(OffsetList));
+                list->offset = newOffset;
+                list->next = trans_vtboffsets;
+                trans_vtboffsets = list;
+
+                expr = makediadicnode(
+                    makemonadicnode(CABI_MakeThisExpr(NULL, newOffset), EINDIRECT),
+                    expr,
+                    EASS);
+            }
+        }
+
+        if (base->is_virtual)
+            newOffset = CClass_VirtualBaseOffset(tclass1, base->base);
+        else
+            newOffset = offset + base->offset;
+
+        expr = CABI_InitVBasePtr1(expr, tclass1, base->base, tclass3, newOffset);
+    }
+
+    return expr;
+}
+
+static Statement *CABI_InitVBasePtrs(Statement *stmt, TypeClass *tclass) {
+    ENode *expr;
+    VClassList *vbase;
+
+    for (vbase = tclass->vbases, trans_vtboffsets = NULL; vbase; vbase = vbase->next) {
+        expr = CABI_InitVBasePtr1(CABI_MakeThisExpr(NULL, vbase->offset), tclass, tclass, vbase->base, 0);
+        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+        stmt->expr = expr;
+    }
+
+    return stmt;
+}
+
+static OffsetList *CABI_GetVBasePath(TypeClass *tclass, TypeClass *baseclass) {
+    ClassList *base;
+    OffsetList *best;
+    OffsetList *list;
+    OffsetList *scan;
+    short bestLength;
+    short length;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base == baseclass && base->is_virtual) {
+            best = lalloc(sizeof(OffsetList));
+            best->next = NULL;
+            best->offset = base->offset;
+            return best;
+        }
+    }
+
+    best = NULL;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if ((list = CABI_GetVBasePath(base->base, baseclass))) {
+            for (scan = list->next, length = 1; scan; scan = scan->next)
+                length++;
+
+            if (base->is_virtual)
+                length++;
+
+            if (!best || length < bestLength) {
+                if (base->is_virtual) {
+                    best = lalloc(sizeof(OffsetList));
+                    best->next = list;
+                    best->offset = base->offset;
+                } else {
+                    best = list;
+                    best->offset += base->offset;
+                }
+                bestLength = length;
+            }
+        }
+    }
+
+    return best;
+}
+
+static ENode *CABI_GetVBasePtr(TypeClass *tclass, TypeClass *baseclass) {
+    OffsetList *path;
+    ENode *expr;
+
+    CError_ASSERT(1127, path = CABI_GetVBasePath(tclass, baseclass));
+
+    expr = makemonadicnode(CABI_MakeThisExpr(NULL, path->offset), EINDIRECT);
+
+    while ((path = path->next)) {
+        if (path->offset)
+            expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), path->offset), EADD);
+        expr = makemonadicnode(expr, EINDIRECT);
+    }
+
+    return expr;
+}
+
+static SInt32 CABI_FindNVBase(TypeClass *tclass, TypeClass *baseclass, SInt32 offset) {
+    ClassList *base;
+    SInt32 tmp;
+
+    if (tclass == baseclass)
+        return offset;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!base->is_virtual && (tmp = CABI_FindNVBase(base->base, baseclass, offset + base->offset)) >= 0)
+            return tmp;
+    }
+
+    return -1;
+}
+
+SInt32 CABI_GetCtorOffsetOffset(TypeClass *tclass, TypeClass *baseclass) {
+    SInt32 baseSize;
+    SInt32 size;
+    char saveAlignMode;
+
+    size = CABI_GetBaseSize(tclass);
+    if (baseclass) {
+        baseSize = CABI_FindNVBase(tclass, baseclass, 0);
+        CError_ASSERT(1178, baseSize >= 0);
+        size -= baseSize;
+    }
+
+    saveAlignMode = copts.align_mode;
+    if (tclass->eflags & CLASS_EFLAGS_F0)
+        copts.align_mode = ((tclass->eflags & CLASS_EFLAGS_F0) >> 4) - 1;
+    size += CMach_MemberAlignValue(TYPE(&stunsignedlong), size);
+    copts.align_mode = saveAlignMode;
+
+    return size;
+}
+
+static Statement *CABI_InitVBaseCtorOffsets(Statement *stmt, TypeClass *tclass) {
+    VClassList *vbase;
+    Object *tempObj;
+    ENode *expr;
+    ENode *vbaseptr;
+    SInt32 vboffset;
+    SInt32 ctorOffsetOffset;
+
+    tempObj = NULL;
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        if (vbase->has_override) {
+            if (!tempObj)
+                tempObj = create_temp_object(TYPE(&void_ptr));
+
+            vboffset = CClass_VirtualBaseOffset(tclass, vbase->base);
+            ctorOffsetOffset = CABI_GetCtorOffsetOffset(vbase->base, NULL);
+            vbaseptr = CABI_GetVBasePtr(tclass, vbase->base);
+            CError_ASSERT(1215, vbaseptr);
+
+            expr = makediadicnode(create_objectnode(tempObj), vbaseptr, EASS);
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = expr;
+
+            expr = makediadicnode(
+                create_objectnode(tempObj),
+                intconstnode(TYPE(&stunsignedlong), ctorOffsetOffset),
+                EADD);
+            expr = makemonadicnode(expr, EINDIRECT);
+            expr->rtype = TYPE(&stunsignedlong);
+            expr = makediadicnode(
+                expr,
+                makediadicnode(
+                    CABI_MakeThisExpr(NULL, vboffset),
+                    create_objectnode(tempObj),
+                    ESUB),
+                EASS);
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = expr;
+        }
+    }
+
+    return stmt;
+}
+
+static Statement *CABI_InitVTablePtrs(Statement *stmt, Object *vtableObj, TypeClass *tclass, TypeClass *baseclass, SInt32 offset, SInt32 voffset) {
+    ClassList *base;
+    BClassList *orig_pathcur;
+    SInt32 newOffset;
+    SInt32 newVOffset;
+    OffsetList *offsetList;
+    SInt32 vtblOffset;
+    ENode *vtblExpr;
+    ENode *pathExpr;
+    BClassList path;
+
+    if (baseclass->vtable->owner == baseclass) {
+        vtblOffset = offset + baseclass->vtable->offset;
+        for (offsetList = trans_vtboffsets; offsetList; offsetList = offsetList->next) {
+            if (vtblOffset == offsetList->offset)
+                break;
+        }
+
+        if (!offsetList) {
+            offsetList = lalloc(sizeof(OffsetList));
+            offsetList->offset = vtblOffset;
+            offsetList->next = trans_vtboffsets;
+            trans_vtboffsets = offsetList;
+
+            vtblExpr = create_objectrefnode(vtableObj);
+            vtblExpr->rtype = TYPE(&void_ptr);
+            if ((vtblOffset = voffset + CABI_GetVTableOffset(baseclass)))
+                vtblExpr = makediadicnode(vtblExpr, intconstnode(TYPE(&stunsignedlong), vtblOffset), EADD);
+
+            pathExpr = CClass_AccessPathCast(&cabi_pathroot, CABI_MakeThisExpr(tclass, 0), 0);
+            if (baseclass->vtable->offset && !canadd(pathExpr, baseclass->vtable->offset)) {
+                pathExpr = makediadicnode(pathExpr, intconstnode(TYPE(&stunsignedlong), baseclass->vtable->offset), EADD);
+                optimizecomm(pathExpr);
+            }
+
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = makediadicnode(makemonadicnode(pathExpr, EINDIRECT), vtblExpr, EASS);
+        }
+    }
+
+    for (base = baseclass->bases; base; base = base->next) {
+        if (base->base->vtable) {
+            orig_pathcur = cabi_pathcur;
+
+            cabi_pathcur->next = &path;
+            path.next = NULL;
+            path.type = TYPE(base->base);
+            cabi_pathcur = &path;
+
+            if (base->is_virtual) {
+                newOffset = CClass_VirtualBaseOffset(tclass, base->base);
+                newVOffset = CClass_VirtualBaseVTableOffset(tclass, base->base);
+            } else {
+                newOffset = offset + base->offset;
+                newVOffset = voffset + base->voffset;
+            }
+
+            stmt = CABI_InitVTablePtrs(stmt, vtableObj, tclass, base->base, newOffset, newVOffset);
+
+            cabi_pathcur = orig_pathcur;
+        }
+    }
+
+    return stmt;
+}
+
+static Boolean CABI_IsOperatorNew(ObjBase *obj) {
+    return
+        obj->otype == OT_OBJECT &&
+        IS_TYPE_FUNC(OBJECT(obj)->type) &&
+        TYPE_FUNC(OBJECT(obj)->type)->args &&
+        TYPE_FUNC(OBJECT(obj)->type)->args->type == CABI_GetSizeTType() &&
+        !TYPE_FUNC(OBJECT(obj)->type)->args->next;
+}
+
+Object *CABI_ConstructorCallsNew(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+    CScopeParseResult pr;
+
+    if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_1)) {
+        if (CScope_FindClassMemberObject(tclass, &pr, CMangler_OperatorName(TK_NEW))) {
+            if (pr.obj_10) {
+                if (CABI_IsOperatorNew(pr.obj_10))
+                    return OBJECT(pr.obj_10);
+            } else {
+                for (nsol = pr.nsol_14; nsol; nsol = nsol->next) {
+                    if (CABI_IsOperatorNew(nsol->object))
+                        return OBJECT(nsol->object);
+                }
+            }
+        }
+
+        return newh_func;
+    }
+
+    return NULL;
+}
+
+void CABI_TransConstructor(Object *obj, Statement *firstStmt, TypeClass *tclass, TransConstructorCallback callback, Boolean has_try) {
+    Statement *stmt;
+    Object *tmpfunc;
+    Object *tmpfunc2;
+    CLabel *label;
+    ENode *expr;
+    ClassList *base;
+    VClassList *vbase;
+    ObjMemberVar *ivar;
+    Type *type;
+    CtorChain *chain;
+    Boolean errorflag;
+
+    stmt = firstStmt;
+
+    if ((tmpfunc = CABI_ConstructorCallsNew(tclass))) {
+        label = newlabel();
+
+        stmt = CFunc_InsertStatement(ST_IFGOTO, firstStmt);
+        stmt->expr = CABI_MakeThisExpr(NULL, 0);
+        stmt->label = label;
+
+        expr = makediadicnode(
+            CABI_MakeThisExpr(NULL, 0),
+            funccallexpr(tmpfunc, intconstnode(CABI_GetSizeTType(), tclass->size), NULL, NULL, NULL),
+            EASS);
+        stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+        stmt->expr = expr;
+        stmt->label = label;
+
+        stmt = CFunc_InsertStatement(ST_RETURN, stmt);
+        stmt->expr = NULL;
+
+        stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+        stmt->label = label;
+        label->stmt = stmt;
+    }
+
+    if (has_try) {
+        for (stmt = firstStmt; ; stmt = stmt->next) {
+            CError_ASSERT(1408, stmt);
+            if (stmt->type == ST_BEGINCATCH)
+                break;
+        }
+    }
+
+    if (!tclass->sominfo) {
+        if (tclass->flags & CLASS_FLAGS_20) {
+            label = newlabel();
+
+            stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+            stmt->expr = CExpr_New_EEQU_Node(CABI_MakeVArgExpr(), intconstnode(TYPE(&stsignedshort), 0));
+            stmt->label = label;
+
+            stmt = CABI_InitVBasePtrs(stmt, tclass);
+
+            for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+                if (!callback) {
+                    for (chain = ctor_chain; chain; chain = chain->next) {
+                        if (chain->what == CtorChain_VBase && chain->u.vbase == vbase)
+                            break;
+                    }
+
+                    if (chain) {
+                        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                        stmt->expr = chain->objexpr;
+                    } else {
+                        expr = CClass_DefaultConstructorCall(
+                            vbase->base,
+                            tclass,
+                            CABI_MakeThisExpr(NULL, vbase->offset),
+                            0, 1, 1, &errorflag);
+                        if (expr) {
+                            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                            stmt->expr = expr;
+                        } else if (errorflag) {
+                            CError_Error(CErrorStr213, tclass, 0, vbase->base, 0);
+                        }
+                    }
+                } else {
+                    stmt = callback(stmt, tclass, vbase->base, vbase->offset, 1);
+                }
+
+                if ((tmpfunc = CClass_Destructor(vbase->base)))
+                    CExcept_RegisterMember(stmt, CABI_ThisArg(), vbase->offset, tmpfunc, CABI_VArg(), 0);
+            }
+
+            stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+            stmt->label = label;
+            label->stmt = stmt;
+        }
+
+        for (base = tclass->bases; base; base = base->next) {
+            if (base->is_virtual)
+                continue;
+
+            if (!callback) {
+                for (chain = ctor_chain; chain; chain = chain->next) {
+                    if (chain->what == CtorChain_Base && chain->u.base == base)
+                        break;
+                }
+
+                if (chain) {
+                    stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                    stmt->expr = chain->objexpr;
+                } else {
+                    expr = CClass_DefaultConstructorCall(
+                        base->base,
+                        tclass,
+                        CABI_MakeThisExpr(NULL, base->offset),
+                        0, 1, 0, &errorflag);
+                    if (expr) {
+                        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                        stmt->expr = expr;
+                    } else if (errorflag) {
+                        CError_Error(CErrorStr213, tclass, 0, base->base, 0);
+                    }
+                }
+            } else {
+                stmt = callback(stmt, tclass, base->base, base->offset, 1);
+            }
+
+            if ((tmpfunc = CClass_Destructor(base->base)))
+                CExcept_RegisterMember(stmt, CABI_ThisArg(), base->offset, tmpfunc, NULL, 0);
+        }
+
+        if (tclass->vtable && tclass->vtable->object && tclass->vtable->owner == tclass) {
+            cabi_pathroot.next = NULL;
+            cabi_pathroot.type = TYPE(tclass);
+            cabi_pathcur = &cabi_pathroot;
+            trans_vtboffsets = NULL;
+
+            stmt = CABI_InitVTablePtrs(stmt, tclass->vtable->object, tclass, tclass, 0, 0);
+        }
+    }
+
+    if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_8000))
+        stmt = CABI_InitVBaseCtorOffsets(stmt, tclass);
+
+    if (!callback) {
+        for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+            for (chain = ctor_chain; chain; chain = chain->next) {
+                if (chain->what == CtorChain_MemberVar && chain->u.membervar == ivar) {
+                    if (IS_TYPE_ARRAY(ivar->type))
+                        chain = NULL;
+                    break;
+                }
+            }
+
+            if (chain) {
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                stmt->expr = chain->objexpr;
+                type = ivar->type;
+                switch (type->type) {
+                    case TYPEARRAY:
+                        do {
+                            type = TPTR_TARGET(type);
+                        } while (IS_TYPE_ARRAY(type));
+                        if (IS_TYPE_CLASS(type)) {
+                            if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+                                CError_ASSERT(1560, type->size);
+                                CExcept_RegisterMemberArray(
+                                    stmt,
+                                    CABI_ThisArg(),
+                                    ivar->offset,
+                                    tmpfunc,
+                                    ivar->type->size / type->size,
+                                    type->size);
+                            }
+                        }
+                        break;
+                    case TYPECLASS:
+                        if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+                            CExcept_RegisterMember(
+                                stmt,
+                                CABI_ThisArg(),
+                                ivar->offset,
+                                tmpfunc,
+                                NULL,
+                                1);
+                        }
+                        break;
+                }
+            } else {
+                type = ivar->type;
+                switch (type->type) {
+                    case TYPEARRAY:
+                        do {
+                            type = TPTR_TARGET(type);
+                        } while (IS_TYPE_ARRAY(type));
+                        if (IS_TYPE_CLASS(type) && CClass_Constructor(TYPE_CLASS(type))) {
+                            if (
+                                (tmpfunc = CClass_DefaultConstructor(TYPE_CLASS(type))) ||
+                                (tmpfunc = CClass_DummyDefaultConstructor(TYPE_CLASS(type)))
+                                )
+                            {
+                                tmpfunc2 = CClass_Destructor(TYPE_CLASS(type));
+                                if (tmpfunc2)
+                                    tmpfunc2 = CABI_GetDestructorObject(tmpfunc2, 1);
+
+                                stmt = CInit_ConstructClassArray(
+                                    stmt,
+                                    TYPE_CLASS(type),
+                                    tmpfunc,
+                                    tmpfunc2,
+                                    CABI_MakeThisExpr(tclass, ivar->offset),
+                                    ivar->type->size / type->size);
+
+                                if (tmpfunc2)
+                                    CExcept_RegisterMemberArray(
+                                        stmt,
+                                        CABI_ThisArg(),
+                                        ivar->offset,
+                                        tmpfunc2,
+                                        ivar->type->size / type->size,
+                                        type->size);
+                            } else {
+                                CError_Error(CErrorStr214, tclass, 0, ivar->name->name);
+                            }
+                        }
+                        break;
+                    case TYPECLASS:
+                        expr = CClass_DefaultConstructorCall(
+                            TYPE_CLASS(type),
+                            NULL,
+                            CABI_MakeThisExpr(tclass, ivar->offset),
+                            1, 1, 0, &errorflag);
+                        if (expr) {
+                            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                            stmt->expr = expr;
+                        } else if (errorflag) {
+                            CError_Error(CErrorStr214, tclass, 0, ivar->name->name);
+                        }
+
+                        if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type)))) {
+                            if (!expr) {
+                                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                                stmt->expr = nullnode();
+                            }
+                            CExcept_RegisterMember(
+                                stmt,
+                                CABI_ThisArg(),
+                                ivar->offset,
+                                tmpfunc,
+                                NULL,
+                                1);
+                        }
+                        break;
+                }
+            }
+        }
+    } else {
+        stmt = callback(stmt, tclass, NULL, 0, 1);
+    }
+
+    if (!tclass->sominfo) {
+        for (stmt = firstStmt->next; stmt; stmt = stmt->next) {
+            if (stmt->type == ST_RETURN) {
+                CError_ASSERT(1661, !stmt->expr);
+                stmt->expr = CABI_MakeThisExpr(NULL, 0);
+            }
+        }
+    }
+}
+
+void CABI_MakeDefaultConstructor(TypeClass *tclass, Object *func) {
+    Boolean saveDebugInfo;
+    CScopeSave savedScope;
+    Statement firstStmt;
+    Statement returnStmt;
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    ctor_chain = NULL;
+    if (tclass->flags & CLASS_FLAGS_20)
+        arguments->next->object->name = CParser_GetUniqueName();
+
+    firstStmt.next = &returnStmt;
+
+    memclrw(&returnStmt, sizeof(Statement));
+    returnStmt.type = ST_RETURN;
+
+    CABI_TransConstructor(func, &firstStmt, tclass, NULL, 0);
+
+    CFunc_CodeCleanup(&firstStmt);
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static ENode *CABI_AssignObject(TypeClass *tclass, ENode *expr1, ENode *expr2) {
+    Object *assignfunc;
+    FuncArg *arg;
+
+    assignfunc = CClass_AssignmentOperator(tclass);
+    if (!assignfunc) {
+        expr1 = makemonadicnode(expr1, EINDIRECT);
+        expr1->rtype = TYPE(tclass);
+        return makediadicnode(expr1, expr2, EASS);
+    }
+
+    CError_ASSERT(1731,
+                  IS_TYPE_FUNC(assignfunc->type) &&
+                  (arg = TYPE_FUNC(assignfunc->type)->args) &&
+                  (arg = arg->next));
+
+    expr2 = argumentpromotion(expr2, arg->type, arg->qual, 1);
+    return funccallexpr(assignfunc, expr1, expr2, NULL, NULL);
+}
+
+static Type *CABI_FindIntegralSizeType(SInt32 size) {
+    if (stunsignedchar.size == size)
+        return TYPE(&stunsignedchar);
+    if (stunsignedshort.size == size)
+        return TYPE(&stunsignedshort);
+    if (stunsignedint.size == size)
+        return TYPE(&stunsignedint);
+    if (stunsignedlong.size == size)
+        return TYPE(&stunsignedlong);
+    if (stunsignedlonglong.size == size)
+        return TYPE(&stunsignedlonglong);
+
+    CError_FATAL(1756);
+    return NULL;
+}
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct CopyRegion {
+    struct CopyRegion *next;
+    Type *type;
+    SInt32 start;
+    SInt32 end;
+    Boolean flag;
+} CopyRegion;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+static CopyRegion *CABI_AppendCopyRegion(CopyRegion *regions, Type *type, SInt32 start, Boolean flag) {
+    CopyRegion *region;
+    SInt32 end;
+
+    if (IS_TYPE_BITFIELD(type))
+        type = TYPE_BITFIELD(type)->bitfieldtype;
+
+    end = start + type->size;
+
+    if (flag) {
+        for (region = regions; region; region = region->next) {
+            if (region->flag) {
+                if (region->start <= start && region->end >= end)
+                    return regions;
+
+                if (region->start >= start && region->end <= end) {
+                    region->type = type;
+                    region->start = start;
+                    region->end = end;
+                    for (region = region->next; region; region = region->next) {
+                        if (region->start >= start && region->end <= end)
+                            region->end = region->start;
+                    }
+                    return regions;
+                }
+            }
+        }
+    }
+
+    if (regions) {
+        region = regions;
+        while (region->next)
+            region = region->next;
+
+        region->next = lalloc(sizeof(CopyRegion));
+        region = region->next;
+    } else {
+        regions = lalloc(sizeof(CopyRegion));
+        region = regions;
+    }
+
+    region->next = NULL;
+    region->type = type;
+    region->start = start;
+    region->end = end;
+    region->flag = flag;
+
+    return regions;
+}
+
+static ENode *CABI_ClassInitLoopCallBack(ENode *var1, ENode *var2) {
+    ENodeList *list;
+
+    var2 = makemonadicnode(var2, EINDIRECT);
+    var2->rtype = TYPE(cabi_loop_class);
+
+    if (cabi_loop_construct) {
+        list = lalloc(sizeof(ENodeList));
+        memclrw(list, sizeof(ENodeList));
+        list->node = var2;
+        return CExpr_ConstructObject(cabi_loop_class, var1, list, 1, 1, 0, 1, 1);
+    } else {
+        return CABI_AssignObject(cabi_loop_class, var1, var2);
+    }
+}
+
+static Statement *CABI_CopyConAssignCB(Statement *stmt, TypeClass *tclass, TypeClass *baseclass, SInt32 offset, Boolean flag) {
+    ENode *expr;
+    ENode *expr2;
+    ENode *startExpr;
+    ENode *endExpr;
+    ENodeList *list;
+    ObjMemberVar *ivar;
+    CopyRegion *regions;
+    Type *type;
+    SInt32 i;
+    SInt32 count;
+    Boolean isFlagNotSet;
+    Object *tmpfunc;
+
+    if (baseclass) {
+        if (baseclass->flags & CLASS_FLAGS_1000) {
+            if (
+                (flag && !CClass_CopyConstructor(baseclass)) ||
+                (!flag && !CClass_AssignmentOperator(baseclass))
+                )
+                return stmt;
+        }
+
+        expr = CABI_MakeCopyConArgExpr(tclass, flag);
+        expr->rtype = TYPE(baseclass);
+        expr->data.monadic = CClass_DirectBasePointerCast(expr->data.monadic, tclass, baseclass);
+
+        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+        if (flag) {
+            list = lalloc(sizeof(ENodeList));
+            list->next = NULL;
+            list->node = expr;
+
+            stmt->expr = CExpr_ConstructObject(
+                baseclass,
+                CABI_MakeThisExpr(NULL, offset),
+                list,
+                1, 0, 0, 0, 1);
+        } else {
+            stmt->expr = CABI_AssignObject(
+                baseclass,
+                CClass_DirectBasePointerCast(CABI_MakeThisExpr(NULL, 0), tclass, baseclass),
+                expr);
+        }
+    } else {
+        isFlagNotSet = !flag;
+        for (ivar = tclass->ivars, regions = NULL; ivar; ivar = ivar->next) {
+            if (ivar->name == vptr_name_node)
+                continue;
+
+            type = ivar->type;
+            if (isFlagNotSet) {
+                if (CParser_IsConst(type, ivar->qual) || IS_TYPE_REFERENCE(type) != 0) {
+                    CError_Error(CErrorStr387, tclass, 0);
+                    isFlagNotSet = 0;
+                }
+            }
+
+            switch (type->type) {
+                case TYPEARRAY:
+                    while (IS_TYPE_ARRAY(type))
+                        type = TPTR_TARGET(type);
+                    if (!IS_TYPE_CLASS(type)) {
+                        regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 1);
+                        break;
+                    }
+                case TYPECLASS:
+                    if (flag) {
+                        if (CClass_CopyConstructor(TYPE_CLASS(type)) || CClass_CopyConstructor(TYPE_CLASS(type))) {
+                            regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 0);
+                            break;
+                        }
+                    } else {
+                        if (CClass_AssignmentOperator(TYPE_CLASS(type))) {
+                            regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 0);
+                            break;
+                        }
+                    }
+                default:
+                    regions = CABI_AppendCopyRegion(regions, ivar->type, ivar->offset, 1);
+            }
+        }
+
+        for (; regions; regions = regions->next) {
+            if (regions->start >= regions->end)
+                continue;
+
+            type = regions->type;
+            expr = CABI_MakeCopyConArgExpr(tclass, flag);
+            expr->rtype = type;
+
+            if (!canadd(expr->data.monadic, regions->start)) {
+                expr->data.monadic = makediadicnode(
+                    expr->data.monadic,
+                    intconstnode(TYPE(&stunsignedlong), regions->start),
+                    EADD);
+                optimizecomm(expr->data.monadic);
+            }
+
+            if (!regions->flag) {
+                if (IS_TYPE_ARRAY(type)) {
+                    while (IS_TYPE_ARRAY(type))
+                        type = TPTR_TARGET(type);
+
+                    CError_ASSERT(1966, IS_TYPE_CLASS(type));
+
+                    if (type->size) {
+                        count = regions->type->size / type->size;
+                        if (count > 4) {
+                            startExpr = CABI_MakeThisExpr(tclass, regions->start);
+                            endExpr = CABI_MakeThisExpr(tclass, regions->start + regions->type->size);
+                            expr = CABI_MakeCopyConArgExpr(tclass, flag)->data.monadic;
+                            if (!canadd(expr, regions->start)) {
+                                expr = makediadicnode(
+                                    expr,
+                                    intconstnode(TYPE(&stunsignedlong), regions->start),
+                                    EADD);
+                                optimizecomm(expr);
+                            }
+
+                            cabi_loop_class = TYPE_CLASS(type);
+                            cabi_loop_construct = flag;
+                            stmt = CFunc_GenerateLoop(
+                                stmt,
+                                CDecl_NewPointerType(type),
+                                startExpr,
+                                endExpr,
+                                intconstnode(TYPE(&stunsignedlong), type->size),
+                                expr,
+                                CABI_ClassInitLoopCallBack);
+                        } else {
+                            for (i = 0, offset = regions->start; i < count; offset += type->size, i++) {
+                                expr = CABI_MakeCopyConArgExpr(tclass, flag);
+                                expr->rtype = type;
+
+                                if (!canadd(expr->data.monadic, offset)) {
+                                    expr->data.monadic = makediadicnode(
+                                        expr->data.monadic,
+                                        intconstnode(TYPE(&stunsignedlong), offset),
+                                        EADD);
+                                    optimizecomm(expr->data.monadic);
+                                }
+
+                                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                                if (flag) {
+                                    list = lalloc(sizeof(ENodeList));
+                                    memclrw(list, sizeof(ENodeList));
+                                    list->node = expr;
+                                    stmt->expr = CExpr_ConstructObject(
+                                        TYPE_CLASS(type),
+                                        CABI_MakeThisExpr(tclass, offset),
+                                        list,
+                                        1, 1, 0, 1, 1);
+                                } else {
+                                    stmt->expr = CABI_AssignObject(
+                                        TYPE_CLASS(type),
+                                        CABI_MakeThisExpr(tclass, offset),
+                                        expr);
+                                }
+                            }
+                        }
+
+                        if (flag && (tmpfunc = CClass_Destructor(TYPE_CLASS(type))))
+                            CExcept_RegisterMemberArray(stmt, CABI_ThisArg(), regions->start, tmpfunc, count, type->size);
+                    }
+                } else {
+                    CError_ASSERT(2027, IS_TYPE_CLASS(type));
+
+                    stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+
+                    if (flag) {
+                        list = lalloc(sizeof(ENodeList));
+                        memclrw(list, sizeof(ENodeList));
+                        list->node = expr;
+                        stmt->expr = CExpr_ConstructObject(
+                            TYPE_CLASS(type),
+                            CABI_MakeThisExpr(tclass, regions->start),
+                            list,
+                            1, 1, 0, 1, 1);
+
+                        if ((tmpfunc = CClass_Destructor(TYPE_CLASS(type))))
+                            CExcept_RegisterMember(stmt, CABI_ThisArg(), regions->start, tmpfunc, NULL, 1);
+                    } else {
+                        stmt->expr = CABI_AssignObject(
+                            TYPE_CLASS(type),
+                            CABI_MakeThisExpr(tclass, regions->start),
+                            expr);
+                    }
+                }
+            } else {
+                if (IS_TYPE_ARRAY(type)) {
+                    if (type->size > 1 && ((regions->start & 1) || (type->size & 1))) {
+                        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                        stmt->expr = funccallexpr(
+                            copy_func,
+                            CABI_MakeThisExpr(tclass, regions->start),
+                            getnodeaddress(expr, 0),
+                            intconstnode(CABI_GetSizeTType(), type->size),
+                            NULL);
+                        continue;
+                    }
+
+                    type = CDecl_NewStructType(type->size, CMach_GetTypeAlign(type));
+                    expr->rtype = type;
+                }
+
+                expr2 = makemonadicnode(CABI_MakeThisExpr(tclass, regions->start), EINDIRECT);
+                expr2->rtype = type;
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                stmt->expr = makediadicnode(expr2, expr, EASS);
+            }
+        }
+    }
+
+    return stmt;
+}
+
+void CABI_MakeDefaultCopyConstructor(TypeClass *tclass, Object *func) {
+    Boolean saveDebugInfo;
+    CScopeSave savedScope;
+    Statement firstStmt;
+    Statement returnStmt;
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    ctor_chain = NULL;
+    if (tclass->flags & CLASS_FLAGS_20)
+        arguments->next->object->name = CParser_GetUniqueName();
+
+    firstStmt.next = &returnStmt;
+
+    memclrw(&returnStmt, sizeof(Statement));
+    returnStmt.type = ST_RETURN;
+
+    CABI_TransConstructor(func, &firstStmt, tclass, CABI_CopyConAssignCB, 0);
+
+    CFunc_CodeCleanup(&firstStmt);
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+void CABI_MakeDefaultAssignmentOperator(TypeClass *tclass, Object *func) {
+    Boolean saveDebugInfo;
+    Statement *stmt;
+    ClassList *base;
+    VClassList *vbase;
+    ENode *expr1;
+    ENode *expr2;
+    CScopeSave savedScope;
+    Statement firstStmt;
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    stmt = curstmt;
+
+    if (tclass->mode == CLASS_MODE_1) {
+        expr1 = makemonadicnode(CABI_MakeThisExpr(tclass, 0), EINDIRECT);
+        expr1->rtype = TYPE(tclass);
+
+        expr2 = CABI_MakeCopyConArgExpr(tclass, 0);
+        expr2->rtype = TYPE(tclass);
+
+        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+        stmt->expr = makediadicnode(expr1, expr2, EASS);
+    } else {
+        for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+            stmt = CABI_CopyConAssignCB(stmt, tclass, vbase->base, vbase->offset, 0);
+        }
+
+        for (base = tclass->bases; base; base = base->next) {
+            if (!base->is_virtual)
+                stmt = CABI_CopyConAssignCB(stmt, tclass, base->base, base->offset, 0);
+        }
+
+        stmt = CABI_CopyConAssignCB(stmt, tclass, NULL, 0, 0);
+    }
+
+    stmt = CFunc_InsertStatement(ST_RETURN, stmt);
+    stmt->expr = CABI_MakeThisExpr(NULL, 0);
+
+    CFunc_CodeCleanup(&firstStmt);
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static Statement *CABI_DestroyMembers(Statement *stmt, ObjMemberVar *ivars, TypeClass *tclass) {
+    Type *type;
+    Object *dtor;
+    ENode *expr;
+
+    for (; ivars; ivars = ivars->next) {
+        type = ivars->type;
+
+        if (IS_TYPE_ARRAY(type)) {
+            while (IS_TYPE_ARRAY(type))
+                type = TPTR_TARGET(type);
+
+            if (IS_TYPE_CLASS(type) && (dtor = CClass_Destructor(TYPE_CLASS(type)))) {
+                dtor = CABI_GetDestructorObject(dtor, 1);
+                stmt = CABI_DestroyMembers(stmt, ivars->next, tclass);
+                expr = create_objectrefnode(dtor);
+                expr->flags |= ENODE_FLAG_80;
+
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                stmt->expr = funccallexpr(
+                    darr_func,
+                    CABI_MakeThisExpr(tclass, ivars->offset),
+                    expr,
+                    intconstnode(TYPE(&stsignedlong), type->size),
+                    intconstnode(TYPE(&stsignedlong), ivars->type->size / type->size)
+                    );
+                return stmt;
+            }
+        } else {
+            if (IS_TYPE_CLASS(type) && (dtor = CClass_Destructor(TYPE_CLASS(type)))) {
+                stmt = CABI_DestroyMembers(stmt, ivars->next, tclass);
+
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                stmt->expr = CABI_DestroyObject(
+                    dtor,
+                    CABI_MakeThisExpr(tclass, ivars->offset),
+                    CABIDestroy1,
+                    1,
+                    0
+                );
+                return stmt;
+            }
+        }
+    }
+
+    return stmt;
+}
+
+static Statement *CABI_DestroyBases(Statement *stmt, ClassList *bases) {
+    ClassList *base;
+    Object *dtor;
+    SInt32 count;
+    SInt32 i;
+
+    for (base = bases, count = 0; base; base = base->next)
+        count++;
+
+    while (count > 0) {
+        base = bases;
+        for (i = 1; i < count; i++)
+            base = base->next;
+
+        if (!base->is_virtual && (dtor = CClass_Destructor(base->base))) {
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = CABI_DestroyObject(
+                dtor,
+                CABI_MakeThisExpr(NULL, base->offset),
+                CABIDestroy0,
+                1,
+                0);
+        }
+
+        count--;
+    }
+
+    return stmt;
+}
+
+static Statement *CABI_DestroyVBases(Statement *stmt, VClassList *vbases) {
+    Object *dtor;
+
+    for (; vbases; vbases = vbases->next) {
+        if ((dtor = CClass_Destructor(vbases->base))) {
+            stmt = CABI_DestroyVBases(stmt, vbases->next);
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            stmt->expr = CABI_DestroyObject(
+                dtor,
+                CABI_MakeThisExpr(NULL, vbases->offset),
+                CABIDestroy0,
+                1,
+                0);
+            break;
+        }
+    }
+
+    return stmt;
+}
+
+void CABI_TransDestructor(Object *obj1, Object *obj2, Statement *stmt, TypeClass *tclass, CABIDestroyMode mode) {
+    CLabel *label2;
+    Boolean flag29;
+    CLabel *label;
+    Statement *scan;
+    Boolean flag25;
+    Boolean flag24;
+    Boolean flag23;
+    CLabel *label3;
+    Object *dealloc;
+    Boolean deallocFlag;
+
+    if (tclass->sominfo) {
+        flag24 = 0;
+        flag25 = 0;
+        flag29 = 0;
+        flag23 = 1;
+    } else {
+        flag24 = 1;
+        flag23 = 1;
+        flag25 = 1;
+        flag29 = 1;
+    }
+
+    label = newlabel();
+
+    for (scan = stmt; scan; scan = scan->next) {
+        if (scan->type == ST_RETURN) {
+            CError_ASSERT(2329, !scan->expr);
+            scan->type = ST_GOTO;
+            scan->label = label;
+        }
+
+        if (scan->next && scan->next->type == ST_RETURN && !scan->next->next) {
+            CError_ASSERT(2334, !scan->next->expr);
+            scan->next = NULL;
+            break;
+        }
+    }
+
+    scan = stmt;
+
+    if (flag29) {
+        label2 = newlabel();
+        scan = CFunc_InsertStatement(ST_IFNGOTO, scan);
+        scan->expr = CABI_MakeThisExpr(NULL, 0);
+        scan->label = label2;
+    }
+
+    if (flag25 && tclass->vtable && tclass->vtable->object && tclass->vtable->owner == tclass) {
+        cabi_pathroot.next = NULL;
+        cabi_pathroot.type = TYPE(tclass);
+        cabi_pathcur = &cabi_pathroot;
+        trans_vtboffsets = NULL;
+        scan = CABI_InitVTablePtrs(scan, tclass->vtable->object, tclass, tclass, 0, 0);
+    }
+
+    if (!tclass->sominfo && (tclass->flags & CLASS_FLAGS_8000))
+        CABI_InitVBaseCtorOffsets(scan, tclass);
+
+    scan = stmt;
+    while (scan->next)
+        scan = scan->next;
+
+    scan = CFunc_InsertStatement(ST_LABEL, scan);
+    scan->label = label;
+    scan->dobjstack = NULL;
+    label->stmt = scan;
+
+    if (flag23 && !(tclass->flags & CLASS_FLAGS_1))
+        scan = CABI_DestroyMembers(scan, tclass->ivars, tclass);
+
+    if (flag25 && tclass->bases)
+        scan = CABI_DestroyBases(scan, tclass->bases);
+
+    if (flag24 && (tclass->flags & CLASS_FLAGS_20)) {
+        label3 = newlabel();
+        scan = CFunc_InsertStatement(ST_IFNGOTO, scan);
+        scan->expr = CABI_MakeVArgExpr();
+        scan->label = label3;
+
+        scan = CABI_DestroyVBases(scan, tclass->vbases);
+
+        scan = CFunc_InsertStatement(ST_LABEL, scan);
+        scan->label = label3;
+        label3->stmt = scan;
+    }
+
+    if (flag29) {
+        scan = CFunc_InsertStatement(ST_IFGOTO, scan);
+        scan->expr = CExpr_New_ELESSEQU_Node(CABI_MakeVArgExpr(), intconstnode(TYPE(&stsignedshort), 0));
+        scan->label = label2;
+
+        scan = CFunc_InsertStatement(ST_EXPRESSION, scan);
+        dealloc = CParser_FindDeallocationObject(TYPE(tclass), NULL, 0, 0, &deallocFlag);
+        if (deallocFlag) {
+            scan->expr = funccallexpr(
+                dealloc,
+                CABI_MakeThisExpr(NULL, 0),
+                intconstnode(CABI_GetSizeTType(), tclass->size),
+                NULL,
+                NULL);
+        } else {
+            scan->expr = funccallexpr(dealloc, CABI_MakeThisExpr(NULL, 0), NULL, NULL, NULL);
+        }
+
+        scan = CFunc_InsertStatement(ST_LABEL, scan);
+        scan->label = label2;
+        label2->stmt = scan;
+    }
+
+    scan = CFunc_InsertStatement(ST_RETURN, scan);
+    if (tclass->sominfo)
+        scan->expr = NULL;
+    else
+        scan->expr = CABI_MakeThisExpr(NULL, 0);
+}
+
+void CABI_MakeDefaultDestructor(TypeClass *tclass, Object *func) {
+    Boolean saveDebugInfo;
+    CScopeSave savedScope;
+    Statement firstStmt;
+    Statement returnStmt;
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    CABI_ApplyClassFlags(func, tclass->eflags, 0);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    firstStmt.next = &returnStmt;
+
+    memclrw(&returnStmt, sizeof(Statement));
+    returnStmt.type = ST_RETURN;
+
+    CFunc_CodeCleanup(&firstStmt);
+
+    CABI_TransDestructor(func, func, &firstStmt, tclass, CABIDestroy0);
+
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+static void CABI_CreateLayeredDestructor(TypeClass *tclass, Object *obj1, Object *func, CABIDestroyMode mode) {
+    Boolean saveDebugInfo;
+    CScopeSave savedScope;
+    Statement firstStmt;
+    Statement returnStmt;
+
+    CError_FATAL(2524);
+
+    CScope_SetFunctionScope(func, &savedScope);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+
+    saveDebugInfo = copts.isGeneratingDebugInfo;
+    copts.isGeneratingDebugInfo = 0;
+
+    CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+    firstStmt.next = &returnStmt;
+
+    memclrw(&returnStmt, sizeof(Statement));
+    returnStmt.type = ST_RETURN;
+
+    CFunc_CodeCleanup(&firstStmt);
+
+    CABI_TransDestructor(obj1, func, &firstStmt, tclass, mode);
+
+    CFunc_Gen(&firstStmt, func, 0);
+
+    CScope_RestoreScope(&savedScope);
+    copts.isGeneratingDebugInfo = saveDebugInfo;
+}
+
+void CABI_MakeLayeredDestructor(TypeClass *tclass, Object *func) {
+    Object *dtor;
+    CABIDestroyMode mode;
+
+    CError_FATAL(2557);
+
+    if (anyerrors || func->access == ACCESSNONE)
+        return;
+
+    if ((dtor = CClass_Destructor(tclass))) {
+        if (CABI_GetDestructorObject(dtor, CABIDestroy0) == func)
+            mode = CABIDestroy0;
+        else if (CABI_GetDestructorObject(dtor, CABIDestroy2) == func)
+            mode = CABIDestroy2;
+        else if (CABI_GetDestructorObject(dtor, CABIDestroy3) == func)
+            mode = CABIDestroy3;
+        else if (CABI_GetDestructorObject(dtor, CABIDestroy1) == func)
+            mode = CABIDestroy1;
+        else
+            CError_FATAL(2567);
+    }
+
+    CABI_CreateLayeredDestructor(tclass, dtor, func, mode);
+}
+
+Object *CABI_GetDestructorObject(Object *obj, CABIDestroyMode mode) {
     return obj;
 }
 
-static void CABI_AddLayeredDestructor() {}
-void CABI_AddLayeredDestructors(TypeClass *tclass) {}
+static void CABI_AddLayeredDestructor(TypeClass *tclass, Object *dtor, HashNameNode *name, Boolean is_virtual) {
+    Object *func;
+
+    CError_FATAL(2667);
+
+    func = CParser_NewFunctionObject(NULL);
+    func->nspace = dtor->nspace;
+    func->name = name;
+    func->type = TYPE(CDecl_MakeDefaultDtorType(tclass, is_virtual));
+    func->qual = Q_20000 | Q_80000;
+    func->qual |= Q_INLINE;
+    CABI_ApplyClassFlags(func, tclass->eflags, 1);
+
+    CError_ASSERT(2678, IS_TYPE_FUNC(func->type));
+    TYPE_FUNC(func->type)->flags |= FUNC_FLAGS_100;
+
+    if (dtor->datatype == DVFUNC) {
+        func->datatype = DVFUNC;
+        CMangler_GetLinkName(func);
+        func->datatype = DFUNC;
+    }
 
-ENode *CABI_DestroyObject(Object *dtor, ENode *objexpr, UInt8 mode, Boolean flag1, Boolean flag2) {}
+    CScope_AddObject(func->nspace, func->name, OBJ_BASE(func));
+}
+
+void CABI_AddLayeredDestructors(TypeClass *tclass) {
+    Object *dtor;
+
+    CError_FATAL(2707);
+
+    if ((dtor = CClass_Destructor(tclass))) {
+        CABI_AddLayeredDestructor(tclass, dtor, CMangler_DeleteDtorName(), 1);
+        CABI_AddLayeredDestructor(tclass, dtor, CMangler_SDeleteDtorName(), 1);
+        if (tclass->vbases)
+            CABI_AddLayeredDestructor(tclass, dtor, CMangler_VBaseDtorName(), 0);
+    }
+}
+
+ENode *CABI_DestroyObject(Object *dtor, ENode *objexpr, CABIDestroyMode mode, Boolean flag1, Boolean flag2) {
+    ENode *expr;
+    short arg;
+    ENodeList *list;
+
+    switch (mode) {
+        case CABIDestroy2:
+        case CABIDestroy3:
+            if (flag2)
+                arg = 1;
+            else
+                arg = -1;
+            break;
+        case CABIDestroy1:
+            arg = -1;
+            break;
+        case CABIDestroy0:
+            arg = 0;
+            break;
+        default:
+            CError_FATAL(2786);
+    }
+
+    expr = lalloc(sizeof(ENode));
+    expr->type = EFUNCCALL;
+    expr->cost = 200;
+    expr->flags = 0;
+    expr->rtype = &stvoid;
+    expr->data.funccall.funcref = create_objectrefnode(dtor);
+    if (flag1)
+        expr->data.funccall.funcref->flags |= ENODE_FLAG_80;
+    expr->data.funccall.functype = TYPE_FUNC(dtor->type);
+    dtor->flags |= OBJECT_FLAGS_UNUSED;
+
+    list = lalloc(sizeof(ENodeList));
+    list->node = objexpr;
+    expr->data.funccall.args = list;
+
+    list->next = lalloc(sizeof(ENodeList));
+    list = list->next;
+    list->next = NULL;
+    list->node = intconstnode(TYPE(&stsignedshort), arg);
+
+    return expr;
+}
diff --git a/compiler_and_linker/unsorted/CClass.c b/compiler_and_linker/unsorted/CClass.c
index 0d2091b..961d99b 100644
--- a/compiler_and_linker/unsorted/CClass.c
+++ b/compiler_and_linker/unsorted/CClass.c
@@ -1,12 +1,24 @@
 #include "compiler/CClass.h"
+#include "compiler/CABI.h"
+#include "compiler/CDecl.h"
 #include "compiler/CError.h"
+#include "compiler/CExpr.h"
+#include "compiler/CInit.h"
 #include "compiler/CInline.h"
+#include "compiler/CMachine.h"
 #include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
 #include "compiler/CParser.h"
+#include "compiler/CRTTI.h"
+#include "compiler/CSOM.h"
 #include "compiler/CompilerTools.h"
 #include "compiler/CodeGen.h"
 #include "compiler/objects.h"
+#include "compiler/scopes.h"
 
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
 typedef struct OVClassBase {
     struct OVClassBase *next;
     struct OVClass *ovclass;
@@ -38,16 +50,19 @@ typedef struct ThunkList {
     SInt32 b;
     SInt32 c;
 } ThunkList;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
 
 static TypeClass *main_class;
 static ThunkList *cclass_thunklist;
 static TypeClass *cclass_isbase_mostderived;
-static void *cclass_isbase_foundoffset; // TODO type
+static SInt32 cclass_isbase_foundoffset;
 static Boolean cclass_isambigbase;
 static short cclass_founddepth;
-static void *vtable_object_data; // TODO type
-static void *vtable_data_size; // TODO type
-static VTableObjectLink *vtable_object_links;
+static char *vtable_object_data;
+static SInt32 vtable_data_size;
+static OLinkList *vtable_object_links;
 static TypeClass *cclass_vbase;
 static OVClass *cclass_ovbase;
 static OVClass *cclass_root;
@@ -60,13 +75,15 @@ static TypeClass *cclass_dominator_oclass;
 static SInt32 cclass_dominator_ooffset;
 static Object *cclass_dominator_eobject;
 
-void CClass_Init(void) {}
+void CClass_Init(void) {
+    cclass_thunklist = NULL;
+}
 
 void CClass_GenThunks(void) {
     ThunkList *list;
 
     for (list = cclass_thunklist; list; list = list->next) {
-        list->obj->flags |= OBJECT_FLAGS_4;
+        list->thunkobj->flags |= OBJECT_FLAGS_4;
         CodeGen_GenVDispatchThunk(list->thunkobj, list->obj, list->a, list->b, list->c);
     }
 }
@@ -100,76 +117,2196 @@ static Object *CClass_ThunkObject(Object *obj, SInt32 a, SInt32 b, SInt32 c) {
     return thunkobj;
 }
 
-static Boolean CClass_IsZeroOffsetClass(TypeClass *a, TypeClass *b) {}
-static UInt8 CClass_IsCovariantResult(Type *a, UInt32 qualA, Type *b, UInt32 qualB) {}
-UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag) {}
-Boolean CClass_IsEmpty(TypeClass *tclass) {}
-Boolean CClass_IsNonStaticMemberFunc(TypeMethod *tmethod) {}
-Object *CClass_DefaultConstructor(TypeClass *tclass) {}
-Object *CClass_DummyDefaultConstructor(TypeClass *tclass) {}
-ENode *CClass_DefaultConstructorCall(TypeClass *a, TypeClass *b, ENode *expr, SInt32 unkshortparam, Boolean flag1, Boolean flag2, Boolean *errorflag) {}
-Object *CClass_AssignmentOperator(TypeClass *tclass) {}
-Object *CClass_CopyConstructor(TypeClass *tclass) {}
-NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name) {}
-NameSpaceObjectList *CClass_Constructor(TypeClass *tclass) {}
-Object *CClass_Destructor(TypeClass *tclass) {}
-Boolean CClass_IsConstructor(Object *obj) {}
-Boolean CClass_IsDestructor(Object *obj) {}
-Boolean CClass_IsPODClass(TypeClass *tclass) {}
-Boolean CClass_IsTrivialCopyClass(TypeClass *tclass) {}
-Boolean CClass_IsTrivialCopyAssignClass(TypeClass *tclass) {}
-Boolean CClass_ReferenceArgument(TypeClass *tclass) {}
-BClassList *CClass_GetPathCopy(BClassList *path, Boolean is_global) {}
-BClassList *CClass_AppendPath(BClassList *a, BClassList *b) {}
-static AccessType CClass_GetPathAccess(BClassList *path) {}
-Boolean CClass_IsMoreAccessiblePath(BClassList *path1, BClassList *path2) {}
-static BClassList *CClass_GetBasePathRec(TypeClass *a, TypeClass *b, SInt32 offset, short depth) {}
-BClassList *CClass_GetBasePath(TypeClass *a, TypeClass *b, short *founddepth, Boolean *isambigbase) {}
-Boolean CClass_IsBaseClass(TypeClass *a, TypeClass *b, short *founddepth, Boolean pathcheckflag, Boolean ambigerrorflag) {}
-TypeClass *CClass_GetQualifiedClass(void) {}
-ENode *CClass_AccessPathCast(BClassList *path, ENode *expr, Boolean flag) {}
-ENode *CClass_ClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean ambigerrorflag, Boolean pathcheckflag) {}
-ENode *CClass_DirectBasePointerCast(ENode *expr, TypeClass *a, TypeClass *b) {}
-SInt32 CClass_GetPathOffset(BClassList *path) {}
-Boolean CClass_ClassDominates(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_VirtualBaseOffset(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_VirtualBaseVTableOffset(TypeClass *a, TypeClass *b) {}
-SInt32 CClass_GetMemberOffset(TypeClass *tclass, HashNameNode *name, ObjMemberVar **obj) {}
-Boolean CClass_OverridesBaseMember(TypeClass *tclass, HashNameNode *name, Object *obj) {}
-static OVClass *CClass_FindOVClass(OVClass *ovclass, TypeClass *tclass, SInt32 offset) {}
-static OVClass *CClass_BuildOVClassTree(OVClass *root, TypeClass *tclass, SInt32 offset, SInt32 voffset) {}
-static Boolean CClass_IsBaseOf(OVClass *a, OVClass *b) {}
-static void CClass_FindOVFunc(OVClass *a, OVClass *b, OVFunc *func) {}
-static TypeList *CClass_GetCoVariantClassList(TypeList *list, TypeClass *tclass, Object *func, Boolean flag) {}
-static TypeMethod *CClass_GetCovariantType(TypeMethod *tmethod, Type *type) {}
-static Object *CClass_FindCovariantFunction(Object *func, Type *type) {}
-static ObjectList *CClass_DeclareCovariantFuncs(ObjectList *list, Object *func, TypeClass *tclass) {}
-void CClass_DefineCovariantFuncs(Object *method, CI_FuncData *ifuncdata) {}
-static void CClass_OverrideOVClassTree(OVClass *ovclass) {}
-static void CClass_AllocVTableRec(OVClass *ovclass) {}
-static Object *CClass_CheckClass(OVClass *ovclass, Boolean errorflag) {}
-static void CClass_AllocVTable(TypeClass *tclass) {}
-static Object *CClass_CheckVirtuals(TypeClass *tclass) {}
-static void CClass_CheckVirtualBaseOverrides(OVClass *a, OVClass *b, Boolean flag) {}
-static void CClass_CheckHideVirtual(OVClass *a, OVClass *b) {}
-void CClass_CheckOverrides(TypeClass *tclass) {}
-static void CClass_FindDominator(TypeClass *tclass1, SInt32 offset1, Object *object1, TypeClass *tclass2, SInt32 offset2, TypeClass *base) {}
-static void CClass_ConstructVTable(TypeClass *tclass, SInt32 voffset, SInt32 offset, TypeClass *base) {}
-void CClass_ClassDefaultFuncAction(TypeClass *tclass) {}
-void CClass_ClassAction(TypeClass *tclass) {}
-void CClass_MakeStaticActionClass(TypeClass *tclass) {}
-Object *CClass_CheckPures(TypeClass *tclass) {}
-void CClass_MemberDef(Object *obj, TypeClass *tclass) {}
-Object *CClass_ThisSelfObject(void) {}
-ENode *CClass_CreateThisSelfExpr(void) {}
-static Boolean CClass_BaseMemberAccess(BClassList *path, AccessType access) {}
-static Boolean CClass_CanAccess(BClassList *path, AccessType access) {}
-void CClass_CheckPathAccess(BClassList *path, Object *obj, AccessType access) {}
-static BClassList *CClass_PathCleanup(BClassList *path, TypeClass *tclass) {}
-void CClass_CheckStaticAccess(BClassList *path, TypeClass *tclass, AccessType access) {}
-void CClass_CheckObjectAccess(BClassList *path, Object *obj) {}
-void CClass_CheckEnumAccess(BClassList *path, ObjEnumConst *objec) {}
-static Type *CClass_PointerTypeCopy(Type *type) {}
-Type *CClass_CombineClassAccessQualifiers(Type *type, UInt32 qual1, UInt32 qual2, UInt32 *outflags) {}
-static void CClass_OptimizeBitFieldAccess(Type **type, SInt32 *offset) {}
-ENode *CClass_AccessMember(ENode *classexpr, Type *type, UInt32 qual, SInt32 offset) {}
+static Boolean CClass_IsZeroOffsetClass(TypeClass *a, TypeClass *b) {
+    while (1) {
+        if (a == b)
+            return 1;
+
+        if (!a->bases || a->bases->is_virtual)
+            return 0;
+
+        a = a->bases->base;
+    }
+}
+
+static UInt8 CClass_IsCovariantResult(Type *a, UInt32 qualA, Type *b, UInt32 qualB, Boolean errorflag) {
+    TypeClass *tclassA;
+    TypeClass *tclassB;
+
+    if (
+        IS_TYPE_POINTER_ONLY(a) &&
+        IS_TYPE_POINTER_ONLY(b) &&
+        TPTR_QUAL(a) == TPTR_QUAL(b) &&
+        !CParser_IsMoreCVQualified(qualB, qualA) &&
+        IS_TYPE_CLASS(TPTR_TARGET(a)) &&
+        IS_TYPE_CLASS(TPTR_TARGET(b))
+        )
+    {
+        tclassA = TYPE_CLASS(TPTR_TARGET(a));
+        tclassB = TYPE_CLASS(TPTR_TARGET(b));
+        if (tclassA == tclassB || CClass_IsBaseClass(tclassB, tclassA, NULL, errorflag, errorflag)) {
+            if (!CClass_IsZeroOffsetClass(tclassB, tclassA))
+                return 2;
+            else
+                return 1;
+        }
+    }
+
+    return 0;
+}
+
+UInt8 CClass_GetOverrideKind(TypeFunc *a, TypeFunc *b, Boolean errorflag) {
+    if (!a->args || !b->args)
+        return 0;
+
+    if (
+        (a->flags & (FUNC_FLAGS_PASCAL | FUNC_FLAGS_F0000000)) != (b->flags & (FUNC_FLAGS_PASCAL | FUNC_FLAGS_F0000000)) ||
+        !is_arglistsame(a->args->next, b->args->next) ||
+        a->args->qual != b->args->qual
+        )
+        return 0;
+
+    if (!is_typesame(a->functype, b->functype)) {
+        switch (CClass_IsCovariantResult(a->functype, a->qual, b->functype, b->qual, errorflag)) {
+            case 0:
+                if (errorflag)
+                    CError_Error(CErrorStr227);
+                return 0;
+            case 1:
+                return 1;
+            case 2:
+                return 2;
+            default:
+                CError_FATAL(225);
+        }
+    }
+
+    return 1;
+}
+
+Boolean CClass_IsEmpty(TypeClass *tclass) {
+    ClassList *base;
+
+    if (tclass->ivars)
+        return 0;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!CClass_IsEmpty(base->base))
+            return 0;
+    }
+
+    return 1;
+}
+
+Boolean CClass_IsNonStaticMemberFunc(TypeFunc *tfunc) {
+    return IS_TYPEFUNC_NONSTATIC_METHOD(tfunc) || (tfunc->flags & FUNC_FLAGS_80);
+}
+
+Object *CClass_DefaultConstructor(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+    Object *object;
+
+    for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+        object = OBJECT(nsol->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+            if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+                if (TYPE_FUNC(object->type)->args->next && !TYPE_FUNC(object->type)->args->next->next)
+                    return object;
+            } else {
+                if (!TYPE_FUNC(object->type)->args->next)
+                    return object;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+Object *CClass_DummyDefaultConstructor(TypeClass *tclass) {
+    Object *ctor;
+    FuncArg *args;
+    NameSpaceObjectList *nsol;
+    HashNameNode *name;
+    TypeMethod *tmethod;
+    Object *object;
+    ObjectList list;
+
+    ctor = NULL;
+
+    for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+        object = OBJECT(nsol->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+            CError_ASSERT(305, args = TYPE_FUNC(object->type)->args);
+            args = args->next;
+            if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+                CError_ASSERT(309, args);
+                args = args->next;
+            }
+            CError_ASSERT(312, args);
+
+            if (args->dexpr) {
+                if (ctor) {
+                    list.next = NULL;
+                    list.object = object;
+                    CError_OverloadedFunctionError(ctor, &list);
+                    break;
+                }
+                ctor = object;
+            }
+        }
+    }
+
+    if (!ctor) {
+        CError_Error(CErrorStr203);
+        return NULL;
+    }
+
+    name = GetHashNameNodeExport("__defctor");
+    if ((nsol = CScope_FindName(tclass->nspace, name))) {
+        CError_ASSERT(339, nsol->object->otype == OT_OBJECT && IS_TYPE_FUNC(OBJECT(nsol->object)->type));
+        return OBJECT(nsol->object);
+    }
+
+    tmethod = galloc(sizeof(TypeMethod));
+    memclrw(tmethod, sizeof(TypeMethod));
+
+    tmethod->type = TYPEFUNC;
+    tmethod->functype = TYPE(&void_ptr);
+    tmethod->flags = FUNC_FLAGS_METHOD;
+    tmethod->theclass = tclass;
+    CDecl_SetFuncFlags(TYPE_FUNC(tmethod), 0);
+
+    if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo)
+        CDecl_AddArgument(TYPE_FUNC(tmethod), TYPE(&stsignedshort));
+
+    CDecl_AddThisPointerArgument(TYPE_FUNC(tmethod), tclass);
+
+    object = CParser_NewCompilerDefFunctionObject();
+    object->type = TYPE(tmethod);
+    object->qual = Q_INLINE | Q_80000;
+    object->nspace = tclass->nspace;
+    object->name = name;
+
+    CScope_AddObject(tclass->nspace, name, OBJ_BASE(object));
+    CParser_RegisterDummyCtorFunction(object, ctor);
+    return object;
+}
+
+ENode *CClass_DefaultConstructorCall(TypeClass *tclass, TypeClass *b, ENode *objexpr, SInt32 varg, Boolean flag1, Boolean flag2, Boolean *errorflag) {
+    NameSpaceObjectList *nsol;
+    Object *ctor;
+    Object *object;
+    FuncArg *args;
+    ENodeList *argexprs;
+    ENode *expr;
+    BClassList *path;
+    BClassList list1;
+    ObjectList objlist;
+    BClassList list2;
+    short founddepth;
+    Boolean isambigbase;
+
+    *errorflag = 0;
+
+    if (!(nsol = CScope_FindName(tclass->nspace, constructor_name_node)))
+        return NULL;
+
+    ctor = NULL;
+    do {
+        object = OBJECT(nsol->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+            CError_ASSERT(397, args = TYPE_FUNC(object->type)->args);
+
+            args = args->next;
+
+            if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+                CError_ASSERT(401, args);
+                args = args->next;
+            }
+
+            if (!args || args->dexpr) {
+                if (ctor) {
+                    objlist.next = NULL;
+                    objlist.object = object;
+                    CError_OverloadedFunctionError(ctor, &objlist);
+                    break;
+                }
+                ctor = object;
+            }
+        }
+    } while ((nsol = nsol->next));
+
+    if (!ctor) {
+        *errorflag = 1;
+        return NULL;
+    }
+
+    if (flag1) {
+        if (b) {
+            if (flag2) {
+                if ((path = CClass_GetBasePath(b, tclass, &founddepth, &isambigbase)))
+                    list1 = *path;
+                else
+                    goto skipCheck;
+            } else {
+                list1.next = &list2;
+                list1.type = TYPE(b);
+                list2.next = NULL;
+                list2.type = TYPE(tclass);
+            }
+        } else {
+            list1.next = NULL;
+            list1.type = TYPE(tclass);
+        }
+        CClass_CheckPathAccess(&list1, ctor, ctor->access);
+    }
+
+skipCheck:
+    if ((tclass->flags & CLASS_FLAGS_20) && !tclass->sominfo) {
+        argexprs = lalloc(sizeof(ENodeList));
+        argexprs->next = NULL;
+        argexprs->node = intconstnode(TYPE(&stsignedshort), varg);
+    } else {
+        argexprs = NULL;
+    }
+
+    CError_ASSERT(471, IS_TYPE_POINTER_ONLY(objexpr->rtype));
+
+    objexpr = makemonadicnode(objexpr, EINDIRECT);
+    objexpr->rtype = TYPE(tclass);
+
+    list1.next = NULL;
+    list1.type = TYPE(tclass);
+
+    expr = CExpr_GenericFuncCall(
+        &list1,
+        objexpr,
+        0,
+        ctor,
+        NULL,
+        NULL,
+        argexprs,
+        0,
+        0,
+        0
+        );
+
+    if (ENODE_IS2(expr, EFUNCCALL, EFUNCCALLP))
+        expr->rtype = CDecl_NewPointerType(TYPE(tclass));
+
+    return expr;
+}
+
+Object *CClass_AssignmentOperator(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+    Object *object;
+
+    for (nsol = CScope_FindName(tclass->nspace, asop_name_node); nsol; nsol = nsol->next) {
+        object = OBJECT(nsol->object);
+        if (
+            object->otype == OT_OBJECT &&
+            IS_TYPE_FUNC(object->type) &&
+            TYPE_FUNC(object->type)->args &&
+            TYPE_FUNC(object->type)->args->next &&
+            !TYPE_FUNC(object->type)->args->next->next
+            )
+        {
+            if (
+                IS_TYPE_CLASS(TYPE_FUNC(object->type)->args->next->type) &&
+                TYPE_CLASS(TYPE_FUNC(object->type)->args->next->type) == tclass
+                )
+                return object;
+
+            if (
+                IS_TYPE_REFERENCE(TYPE_FUNC(object->type)->args->next->type) &&
+                TPTR_TARGET(TYPE_FUNC(object->type)->args->next->type) == TYPE(tclass)
+                )
+                return object;
+        }
+    }
+
+    return NULL;
+}
+
+Object *CClass_CopyConstructor(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+    Object *object;
+    FuncArg *args;
+
+    if (tclass->sominfo)
+        return NULL;
+
+    for (nsol = CScope_FindName(tclass->nspace, constructor_name_node); nsol; nsol = nsol->next) {
+        object = OBJECT(nsol->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+            CError_ASSERT(532, args = TYPE_FUNC(object->type)->args);
+
+            args = args->next;
+
+            if (tclass->flags & CLASS_FLAGS_20) {
+                CError_ASSERT(536, args);
+                args = args->next;
+            }
+
+            if (
+                args &&
+                args != &elipsis &&
+                (!args->next || args->next->dexpr) &&
+                IS_TYPE_REFERENCE(args->type) &&
+                TPTR_TARGET(args->type) == TYPE(tclass)
+                )
+                return object;
+        }
+    }
+
+    return NULL;
+}
+
+NameSpaceObjectList *CClass_MemberObject(TypeClass *tclass, HashNameNode *name) {
+    NameSpaceObjectList *nsol;
+
+    if ((nsol = CScope_FindName(tclass->nspace, name)) && nsol->object->otype == OT_OBJECT)
+        return nsol;
+
+    return NULL;
+}
+
+NameSpaceObjectList *CClass_Constructor(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+
+    if (
+        (nsol = CScope_FindName(tclass->nspace, constructor_name_node)) &&
+        nsol->object->otype == OT_OBJECT &&
+        IS_TYPE_FUNC(OBJECT(nsol->object)->type)
+        )
+        return nsol;
+
+    return NULL;
+}
+
+Object *CClass_Destructor(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+
+    for (nsol = CScope_FindName(tclass->nspace, destructor_name_node); nsol; nsol = nsol->next) {
+        if (
+            nsol->object->otype == OT_OBJECT &&
+            IS_TYPE_FUNC(OBJECT(nsol->object)->type)
+            )
+            return OBJECT(nsol->object);
+    }
+
+    return NULL;
+}
+
+Boolean CClass_IsConstructor(Object *obj) {
+    return obj && IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_1000);
+}
+
+Boolean CClass_IsDestructor(Object *obj) {
+    return obj && IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_2000);
+}
+
+Boolean CClass_IsPODClass(TypeClass *tclass) {
+    NameSpaceObjectList *nsol;
+    Object *object;
+    ObjMemberVar *ivar;
+    Type *type;
+
+    if (tclass->vtable || tclass->bases || CClass_Destructor(tclass))
+        return 0;
+
+    for (nsol = CClass_Constructor(tclass); nsol; nsol = nsol->next) {
+        if (
+            nsol->object->otype == OT_OBJECT &&
+            IS_TYPE_FUNC(OBJECT(nsol->object)->type) &&
+            !(TYPE_FUNC(OBJECT(nsol->object)->type)->flags & FUNC_FLAGS_100)
+            )
+            return 0;
+    }
+
+    object = CClass_AssignmentOperator(tclass);
+    if (object && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+        return 0;
+
+    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+        if (ivar->access != ACCESSPUBLIC)
+            return 0;
+
+        type = ivar->type;
+        while (IS_TYPE_ARRAY(type))
+            type = TPTR_TARGET(type);
+
+        switch (type->type) {
+            case TYPECLASS:
+                if (!CClass_IsPODClass(TYPE_CLASS(type)))
+                    return 0;
+                break;
+            case TYPEMEMBERPOINTER:
+                return 0;
+            case TYPEPOINTER:
+                if (TPTR_QUAL(type) & Q_REFERENCE)
+                    return 0;
+                break;
+        }
+    }
+
+    return 1;
+}
+
+Boolean CClass_IsTrivialCopyClass(TypeClass *tclass) {
+    Object *object;
+    ClassList *base;
+    ObjMemberVar *ivar;
+    Type *type;
+
+    if (tclass->vtable || tclass->vbases || CClass_Destructor(tclass))
+        return 0;
+
+    object = CClass_CopyConstructor(tclass);
+    if (object && IS_TYPE_FUNC(object->type) && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+        return 0;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (!CClass_IsTrivialCopyClass(base->base))
+            return 0;
+    }
+
+    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+        type = ivar->type;
+        while (IS_TYPE_ARRAY(type))
+            type = TPTR_TARGET(type);
+
+        if (IS_TYPE_CLASS(type) && !CClass_IsTrivialCopyClass(TYPE_CLASS(type)))
+            return 0;
+    }
+
+    return 1;
+}
+
+Boolean CClass_IsTrivialCopyAssignClass(TypeClass *tclass) {
+    Object *object;
+    ObjMemberVar *ivar;
+    Type *type;
+
+    if (tclass->vtable || tclass->bases || CClass_Destructor(tclass))
+        return 0;
+
+    object = CClass_AssignmentOperator(tclass);
+    if (object && !(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100))
+        return 0;
+
+    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+        type = ivar->type;
+        while (IS_TYPE_ARRAY(type))
+            type = TPTR_TARGET(type);
+
+        if (IS_TYPE_REFERENCE(type))
+            return 0;
+        if (CParser_IsConst(type, ivar->qual))
+            return 0;
+        if (IS_TYPE_CLASS(type) && !CClass_IsTrivialCopyAssignClass(TYPE_CLASS(type)))
+            return 0;
+    }
+
+    return 1;
+}
+
+Boolean CClass_ReferenceArgument(TypeClass *tclass) {
+    if ((tclass->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+        CDecl_CompleteType(TYPE(tclass));
+
+    if (copts.simple_class_byval)
+        return !CClass_IsTrivialCopyClass(tclass);
+
+    return CClass_Destructor(tclass) || CClass_CopyConstructor(tclass);
+}
+
+BClassList *CClass_GetPathCopy(BClassList *path, Boolean is_global) {
+    BClassList *last;
+    BClassList *copy;
+
+    if (!path)
+        return NULL;
+
+    copy = last = is_global ? galloc(sizeof(BClassList)) : lalloc(sizeof(BClassList));
+    last->next = path->next;
+    last->type = path->type;
+
+    while ((path = path->next)) {
+        last->next = is_global ? galloc(sizeof(BClassList)) : lalloc(sizeof(BClassList));
+        last = last->next;
+        last->next = path->next;
+        last->type = path->type;
+    }
+
+    return copy;
+}
+
+BClassList *CClass_AppendPath(BClassList *dest, BClassList *src) {
+    BClassList *last;
+
+    if (!(last = dest))
+        return src;
+
+    while (last->next)
+        last = last->next;
+
+    while (src && src->type == last->type)
+        src = src->next;
+
+    last->next = src;
+    return dest;
+}
+
+static AccessType CClass_GetPathAccess(BClassList *path) {
+    AccessType result;
+    ClassList *base;
+    TypeClass *tclass;
+
+    CError_ASSERT(930, path);
+
+    result = ACCESSPUBLIC;
+
+    while (1) {
+        tclass = TYPE_CLASS(path->type);
+        if (!(path = path->next))
+            break;
+
+        for (base = tclass->bases; base; base = base->next) {
+            if (base->base == TYPE_CLASS(path->type))
+                break;
+        }
+
+        CError_ASSERT(939, base);
+
+        switch (base->access) {
+            case ACCESSPUBLIC:
+                break;
+            case ACCESSPROTECTED:
+                if (result == ACCESSPUBLIC)
+                    result = ACCESSPROTECTED;
+                break;
+            case ACCESSPRIVATE:
+                if (result == ACCESSPUBLIC || result == ACCESSPROTECTED)
+                    result = ACCESSPRIVATE;
+                else
+                    return ACCESSNONE;
+                break;
+            case ACCESSNONE:
+                return ACCESSNONE;
+            default:
+                CError_FATAL(960);
+        }
+    }
+
+    return result;
+}
+
+Boolean CClass_IsMoreAccessiblePath(BClassList *path1, BClassList *path2) {
+    switch (CClass_GetPathAccess(path2)) {
+        case ACCESSPUBLIC:
+            return 0;
+        case ACCESSNONE:
+            return 1;
+        default:
+            CError_FATAL(978);
+        case ACCESSPROTECTED:
+            switch (CClass_GetPathAccess(path1)) {
+                case ACCESSPUBLIC:
+                    return 1;
+                case ACCESSPRIVATE:
+                case ACCESSPROTECTED:
+                case ACCESSNONE:
+                    return 0;
+                default:
+                    CError_FATAL(987);
+            }
+        case ACCESSPRIVATE:
+            switch (CClass_GetPathAccess(path1)) {
+                case ACCESSPUBLIC:
+                case ACCESSPROTECTED:
+                    return 1;
+                case ACCESSPRIVATE:
+                case ACCESSNONE:
+                    return 0;
+                default:
+                    CError_FATAL(997);
+            }
+    }
+
+    return 0;
+}
+
+static BClassList *CClass_GetBasePathRec(TypeClass *a, TypeClass *b, SInt32 offset, short depth) {
+    ClassList *base;
+    BClassList *checkpath;
+    BClassList *bestpath;
+    BClassList *newpath;
+    SInt32 newOffset;
+
+    for (base = a->bases, bestpath = NULL; base; base = base->next) {
+        if (base->is_virtual)
+            newOffset = CClass_VirtualBaseOffset(cclass_isbase_mostderived, base->base);
+        else
+            newOffset = offset + base->offset;
+
+        if (base->base == b) {
+            if (cclass_founddepth && newOffset != cclass_isbase_foundoffset) {
+                cclass_isambigbase = 1;
+                return NULL;
+            }
+
+            cclass_isbase_foundoffset = newOffset;
+            cclass_founddepth = depth;
+
+            bestpath = lalloc(sizeof(BClassList));
+            bestpath->next = NULL;
+            bestpath->type = TYPE(b);
+        } else if ((checkpath = CClass_GetBasePathRec(base->base, b, newOffset, depth + 1))) {
+            newpath = lalloc(sizeof(BClassList));
+            newpath->next = checkpath;
+            newpath->type = TYPE(base->base);
+            if (!bestpath || CClass_IsMoreAccessiblePath(newpath, bestpath))
+                bestpath = newpath;
+        }
+    }
+
+    return bestpath;
+}
+
+BClassList *CClass_GetBasePath(TypeClass *a, TypeClass *b, short *founddepth, Boolean *isambigbase) {
+    BClassList *path;
+    BClassList *result;
+
+    if ((a->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+        CDecl_CompleteType(TYPE(a));
+    if ((b->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
+        CDecl_CompleteType(TYPE(b));
+
+    cclass_founddepth = 0;
+    cclass_isbase_mostderived = a;
+    cclass_isbase_foundoffset = -1;
+    cclass_isambigbase = 0;
+
+    if ((path = CClass_GetBasePathRec(a, b, 0, 1))) {
+        *founddepth = cclass_founddepth;
+        *isambigbase = cclass_isambigbase;
+
+        result = lalloc(sizeof(BClassList));
+        result->next = path;
+        result->type = TYPE(a);
+        return result;
+    } else {
+        *isambigbase = 0;
+        return NULL;
+    }
+}
+
+Boolean CClass_IsBaseClass(TypeClass *a, TypeClass *b, short *founddepth, Boolean pathcheckflag, Boolean ambigerrorflag) {
+    BClassList *path;
+    short depth;
+    Boolean isambigbase;
+
+    if ((path = CClass_GetBasePath(a, b, &depth, &isambigbase))) {
+        if (isambigbase && ambigerrorflag)
+            CError_Error(CErrorStr188);
+
+        if (pathcheckflag)
+            CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+
+        if (founddepth)
+            *founddepth = depth;
+
+        return 1;
+    }
+
+    return 0;
+}
+
+TypeClass *CClass_GetQualifiedClass(void) {
+    DeclInfo di;
+
+    memclrw(&di, sizeof(di));
+    CParser_GetDeclSpecs(&di, 0);
+
+    if (IS_TYPE_CLASS(di.thetype))
+        return TYPE_CLASS(di.thetype);
+
+    return NULL;
+}
+
+ENode *CClass_AccessPathCast(BClassList *path, ENode *expr, Boolean reverse) {
+    ClassList *base;
+    SInt32 offset;
+
+    while (path && path->next) {
+        base = TYPE_CLASS(path->type)->bases;
+        while (1) {
+            if (base->base == TYPE_CLASS(path->next->type))
+                break;
+            CError_ASSERT(1157, base = base->next);
+        }
+
+        if (base->is_virtual) {
+            if (reverse) {
+                CError_Error(CErrorStr164);
+                break;
+            }
+
+            if (!base->base->sominfo) {
+                offset = base->offset;
+                if (offset && !canadd(expr, offset)) {
+                    expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+                    optimizecomm(expr);
+                }
+
+                expr->rtype = CDecl_NewPointerType(CDecl_NewPointerType(TYPE(base->base)));
+                expr = makemonadicnode(expr, EINDIRECT);
+                expr->rtype = expr->data.monadic->rtype;
+            }
+        } else {
+            offset = base->offset;
+            if (offset) {
+                if (reverse)
+                    offset = -offset;
+                if (!canadd(expr, offset)) {
+                    expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
+                    optimizecomm(expr);
+                }
+            }
+        }
+
+        path = path->next;
+    }
+
+    return expr;
+}
+
+ENode *CClass_ClassPointerCast(ENode *expr, TypeClass *a, TypeClass *b, Boolean typconflag, Boolean ambigerrorflag, Boolean pathcheckflag) {
+    BClassList *path;
+    Boolean reverse;
+    short depth;
+    Boolean isambigbase;
+
+    reverse = 0;
+
+    if (a != b) {
+        if (!(path = CClass_GetBasePath(a, b, &depth, &isambigbase))) {
+            CError_ASSERT(1216, typconflag);
+            if ((path = CClass_GetBasePath(b, a, &depth, &isambigbase))) {
+                reverse = 1;
+                goto doCast;
+            }
+        } else {
+        doCast:
+            if (isambigbase && ambigerrorflag)
+                CError_Error(CErrorStr188);
+            if (pathcheckflag)
+                CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+            if (!(a->flags & CLASS_FLAGS_10) && !b->sominfo)
+                expr = CClass_AccessPathCast(path, expr, reverse);
+        }
+    }
+
+    if (typconflag && ENODE_IS(expr, EINDIRECT) && IS_TYPE_POINTER_ONLY(expr->rtype))
+        expr = makemonadicnode(expr, ETYPCON);
+
+    return expr;
+}
+
+ENode *CClass_DirectBasePointerCast(ENode *expr, TypeClass *a, TypeClass *b) {
+    ClassList *base;
+    VClassList *vbase;
+    BClassList *path;
+    BClassList list1;
+    BClassList list2;
+    short depth;
+    Boolean isambigbase;
+
+    for (base = a->bases; base; base = base->next) {
+        if (base->base == b) {
+            list1.next = &list2;
+            list1.type = TYPE(a);
+            list2.next = NULL;
+            list2.type = TYPE(b);
+            return CClass_AccessPathCast(&list1, expr, 0);
+        }
+    }
+
+    for (vbase = a->vbases; vbase; vbase = vbase->next) {
+        if (vbase->base == b) {
+            CError_ASSERT(1273, path = CClass_GetBasePath(a, b, &depth, &isambigbase));
+            return CClass_AccessPathCast(path, expr, 0);
+        }
+    }
+
+    CError_FATAL(1277);
+    return expr;
+}
+
+SInt32 CClass_GetPathOffset(BClassList *path) {
+    SInt32 offset;
+    ClassList *base;
+
+    offset = 0;
+
+    while (path->next) {
+        if (path->type != path->next->type) {
+            for (base = TYPE_CLASS(path->type)->bases; base; base = base->next) {
+                if (base->base == TYPE_CLASS(path->next->type))
+                    break;
+            }
+
+            if (!base) {
+                CError_Error(CErrorStr221);
+                return offset;
+            }
+        }
+
+        if (base->is_virtual)
+            return -1;
+        offset += base->offset;
+
+        path = path->next;
+    }
+
+    return offset;
+}
+
+Boolean CClass_ClassDominates(TypeClass *tclass, TypeClass *baseclass) {
+    ClassList *base;
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base == baseclass || CClass_ClassDominates(base->base, baseclass))
+            return 1;
+    }
+
+    return 0;
+}
+
+SInt32 CClass_VirtualBaseOffset(TypeClass *tclass, TypeClass *baseclass) {
+    VClassList *vbase;
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        if (vbase->base == baseclass)
+            return vbase->offset;
+    }
+
+    CError_FATAL(1342);
+    return 0;
+}
+
+SInt32 CClass_VirtualBaseVTableOffset(TypeClass *tclass, TypeClass *baseclass) {
+    VClassList *vbase;
+
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        if (vbase->base == baseclass)
+            return vbase->voffset;
+    }
+
+    CError_FATAL(1359);
+    return 0;
+}
+
+SInt32 CClass_GetMemberOffset(TypeClass *tclass, HashNameNode *name, ObjMemberVar **resultIvar) {
+    ObjMemberVar *ivar;
+    ClassList *base;
+    SInt32 offset;
+    SInt32 tmp;
+    Boolean foundflag;
+
+    for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+        if (ivar->name == name) {
+            if (resultIvar)
+                *resultIvar = ivar;
+            return ivar->offset;
+        }
+    }
+
+    for (base = tclass->bases, foundflag = 0; base; base = base->next) {
+        switch ((tmp = CClass_GetMemberOffset(base->base, name, resultIvar))) {
+            case -3:
+            case -2:
+                return tmp;
+            case -1:
+                break;
+            default:
+                if (base->is_virtual)
+                    return -3;
+                if (foundflag)
+                    return -2;
+                foundflag = 1;
+                offset = base->offset + tmp;
+        }
+    }
+
+    return foundflag ? offset : -1;
+}
+
+Boolean CClass_OverridesBaseMember(TypeClass *tclass, HashNameNode *name, Object *obj) {
+    NameSpaceObjectList *nsol;
+    ClassList *base;
+    Boolean result;
+
+    result = 0;
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base->vtable) {
+            for (nsol = CScope_FindName(base->base->nspace, name); nsol; nsol = nsol->next) {
+                if (
+                    nsol->object->otype == OT_OBJECT &&
+                    OBJECT(nsol->object)->datatype == DVFUNC &&
+                    CClass_GetOverrideKind(TYPE_FUNC(OBJECT(nsol->object)->type), TYPE_FUNC(obj->type), 1)
+                    )
+                    result = 1;
+            }
+
+            if (CClass_OverridesBaseMember(base->base, name, obj))
+                result = 1;
+        }
+    }
+
+    return result;
+}
+
+static OVClass *CClass_FindOVClass(OVClass *ovclass, TypeClass *tclass, SInt32 offset) {
+    OVClassBase *ovbase;
+
+    if (ovclass->tclass == tclass && ovclass->offset == offset)
+        return ovclass;
+
+    for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next) {
+        if ((ovclass = CClass_FindOVClass(ovbase->ovclass, tclass, offset)))
+            return ovclass;
+    }
+
+    return NULL;
+}
+
+static OVClass *CClass_BuildOVClassTree(OVClass *root, TypeClass *tclass, SInt32 offset, SInt32 voffset) {
+    ClassList *base;
+    Object *object;
+    OVClass *tree;
+    OVFunc *ovfunc;
+    OVClassBase *ovbase;
+    SInt32 vboffset;
+    SInt32 vbvoffset;
+    CScopeObjectIterator iter;
+
+    tree = lalloc(sizeof(OVClass));
+    memclrw(tree, sizeof(OVClass));
+
+    tree->tclass = tclass;
+    tree->offset = offset;
+    tree->voffset = voffset;
+    if (!root)
+        root = tree;
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (object->datatype == DVFUNC) {
+            ovfunc = lalloc(sizeof(OVFunc));
+            memclrw(ovfunc, sizeof(OVFunc));
+
+            ovfunc->next = tree->vfuncs;
+            ovfunc->obj = object;
+            tree->vfuncs = ovfunc;
+        }
+    }
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base->vtable || base->base->sominfo) {
+            ovbase = lalloc(sizeof(OVClassBase));
+            memclrw(ovbase, sizeof(OVClassBase));
+
+            if (base->is_virtual) {
+                vboffset = CClass_VirtualBaseOffset(main_class, base->base);
+                if (!(ovbase->ovclass = CClass_FindOVClass(root, base->base, vboffset))) {
+                    vbvoffset = CClass_VirtualBaseVTableOffset(main_class, base->base);
+                    ovbase->ovclass = CClass_BuildOVClassTree(root, base->base, vboffset, vbvoffset);
+                }
+                ovbase->is_virtual = 1;
+            } else {
+                ovbase->ovclass = CClass_BuildOVClassTree(
+                    root,
+                    base->base,
+                    offset + base->offset,
+                    voffset + base->voffset);
+                ovbase->is_virtual = 0;
+            }
+
+            ovbase->next = tree->bases;
+            tree->bases = ovbase;
+        }
+    }
+
+    return tree;
+}
+
+static Boolean CClass_IsBaseOf(OVClass *a, OVClass *b) {
+    OVClassBase *ovbase;
+
+    for (ovbase = b->bases; ovbase; ovbase = ovbase->next) {
+        if (
+            (ovbase->ovclass->tclass == a->tclass && ovbase->ovclass->offset == a->offset) ||
+            CClass_IsBaseOf(a, ovbase->ovclass)
+            )
+        {
+            if (!cclass_ovbase && ovbase->is_virtual)
+                cclass_ovbase = ovbase->ovclass;
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static void CClass_FindOVFunc(OVClass *a, OVClass *b, OVFunc *func) {
+    OVFunc *scan;
+    OVClassBase *ovbase;
+    UInt8 overrideKind;
+
+    if (CClass_IsBaseOf(b, a)) {
+        for (scan = a->vfuncs; scan; scan = scan->next) {
+            if (
+                (func->obj->name == scan->obj->name) &&
+                (overrideKind = CClass_GetOverrideKind(TYPE_FUNC(func->obj->type), TYPE_FUNC(scan->obj->type), 0))
+                )
+            {
+                if (func->ovc8) {
+                    if (func->ovc8->tclass == a->tclass || CClass_ClassDominates(func->ovc8->tclass, a->tclass))
+                        return;
+                    if (!CClass_ClassDominates(a->tclass, func->ovc8->tclass)) {
+                        func->ovf10 = scan;
+                        return;
+                    }
+                }
+
+                if (a == cclass_root) {
+                    TYPE_FUNC(scan->obj->type)->flags |= FUNC_FLAGS_20;
+                    if (overrideKind == 2)
+                        TYPE_FUNC(scan->obj->type)->flags |= FUNC_FLAGS_400000;
+                }
+
+                func->ovc8 = a;
+                func->ovfC = scan;
+                func->ovf10 = NULL;
+                return;
+            }
+        }
+
+        for (ovbase = a->bases; ovbase; ovbase = ovbase->next)
+            CClass_FindOVFunc(ovbase->ovclass, b, func);
+    }
+}
+
+static TypeList *CClass_GetCoVariantClassList(TypeList *list, TypeClass *tclass, Object *func, Boolean flag) {
+    Object *object;
+    TypeList *scan;
+    Type *type;
+    ClassList *base;
+    CScopeObjectIterator iter;
+
+    if (!flag) {
+        CScope_InitObjectIterator(&iter, tclass->nspace);
+        while (1) {
+            if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                break;
+
+            if (
+                object->name == func->name &&
+                object->datatype == DVFUNC &&
+                CClass_GetOverrideKind(TYPE_FUNC(object->type), TYPE_FUNC(func->type), 0) == 2
+                )
+            {
+                CError_ASSERT(1686,
+                              IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->functype) &&
+                              IS_TYPE_CLASS(TPTR_TARGET(TYPE_FUNC(object->type)->functype)));
+
+                type = TPTR_TARGET(TYPE_FUNC(object->type)->functype);
+                for (scan = list; scan; scan = scan->next) {
+                    if (scan->type == type)
+                        break;
+                }
+
+                if (!scan) {
+                    scan = lalloc(sizeof(TypeList));
+                    scan->type = type;
+                    scan->next = list;
+                    list = scan;
+                }
+            }
+        }
+    }
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base->vtable)
+            list = CClass_GetCoVariantClassList(list, base->base, func, 0);
+    }
+
+    return list;
+}
+
+static TypeMethod *CClass_GetCovariantType(TypeMethod *tmethod, Type *type) {
+    TypePointer *tptr;
+    TypeMethod *result;
+
+    CError_ASSERT(1724,
+                  IS_TYPE_METHOD(tmethod) &&
+                  IS_TYPE_POINTER_ONLY(tmethod->functype));
+
+    tptr = galloc(sizeof(TypePointer));
+    *tptr = *TYPE_POINTER(tmethod->functype);
+    tptr->target = type;
+
+    result = galloc(sizeof(TypeMethod));
+    *result = *tmethod;
+    result->flags &= ~(FUNC_FLAGS_20 | FUNC_FLAGS_400000);
+    result->functype = TYPE(tptr);
+    return result;
+}
+
+static Object *CClass_FindCovariantFunction(Object *func, Type *type) {
+    NameSpaceObjectList *nsol;
+
+    nsol = CScope_FindName(
+        TYPE_METHOD(func->type)->theclass->nspace,
+        CMangler_GetCovariantFunctionName(func, type));
+
+    CError_ASSERT(1754, nsol && !nsol->next && nsol->object->otype == OT_OBJECT);
+
+    return OBJECT(nsol->object);
+}
+
+static ObjectList *CClass_DeclareCovariantFuncs(ObjectList *list, Object *func, TypeClass *tclass) {
+    Object *newfunc;
+    HashNameNode *name;
+    TypeList *types;
+    ObjectList *newlist;
+
+    for (types = CClass_GetCoVariantClassList(NULL, tclass, func, 1); types; types = types->next) {
+        name = CMangler_GetCovariantFunctionName(func, types->type);
+
+        newfunc = galloc(sizeof(Object));
+        memclrw(newfunc, sizeof(Object));
+
+        newfunc->otype = OT_OBJECT;
+        newfunc->datatype = DFUNC;
+        newfunc->section = func->section;
+        newfunc->nspace = func->nspace;
+        newfunc->name = name;
+        newfunc->type = TYPE(CClass_GetCovariantType(TYPE_METHOD(func->type), types->type));
+        newfunc->qual = func->qual & ~Q_INLINE;
+        newfunc->sclass = func->sclass;
+        newfunc->u.func.linkname = name;
+
+        newlist = lalloc(sizeof(ObjectList));
+        newlist->object = newfunc;
+        newlist->next = list;
+        list = newlist;
+    }
+
+    return list;
+}
+
+void CClass_DefineCovariantFuncs(Object *method, CI_FuncData *ifuncdata) {
+    NameSpace *nspace;
+    TypeList *types;
+    Object *covariantFunc;
+    Statement *stmt;
+    Type *tptr;
+    Statement firstStmt;
+
+    for (types = CClass_GetCoVariantClassList(NULL, TYPE_METHOD(method->type)->theclass, method, 1); types; types = types->next) {
+        covariantFunc = CClass_FindCovariantFunction(method, types->type);
+        tptr = CDecl_NewPointerType(types->type);
+
+        nspace = CFunc_FuncGenSetup(&firstStmt, covariantFunc);
+        CInline_UnpackIFunctionData(covariantFunc, ifuncdata, &firstStmt);
+
+        for (stmt = &firstStmt; stmt; stmt = stmt->next) {
+            if (stmt->type == ST_RETURN && stmt->expr)
+                stmt->expr = CExpr_AssignmentPromotion(stmt->expr, tptr, ENODE_QUALS(stmt->expr), 0);
+        }
+
+        CFunc_Gen(&firstStmt, covariantFunc, 0);
+        cscope_current = nspace->parent;
+    }
+}
+
+static void CClass_OverrideOVClassTree(OVClass *ovclass) {
+    OVClassBase *ovbase;
+    OVFunc *ovfunc;
+
+    if (cclass_root != ovclass) {
+        for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next)
+            CClass_FindOVFunc(cclass_root, ovclass, ovfunc);
+    }
+
+    for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next)
+        CClass_OverrideOVClassTree(ovbase->ovclass);
+}
+
+static void CClass_AllocVTableRec(OVClass *ovclass) {
+    OVFunc *ovfunc;
+    Object *object;
+    SInt32 offset27;
+    SInt32 offset26;
+    SInt32 offset23;
+    OVClassBase *ovbase;
+    OLinkList *link;
+
+    if (ovclass->alloced_vtable)
+        return;
+
+    for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+        offset27 = ovclass->voffset + TYPE_METHOD(ovfunc->obj->type)->x1E + CABI_GetVTableOffset(ovclass->tclass);
+        CError_ASSERT(1867, offset27 < vtable_data_size);
+
+        if (!(vtable_object_data[offset27])) {
+            if (ovfunc->ovfC) {
+                object = ovfunc->ovfC->obj;
+                if (
+                    (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_400000) &&
+                    CClass_GetOverrideKind(TYPE_FUNC(ovfunc->obj->type), TYPE_FUNC(object->type), 0) == 2
+                    )
+                {
+                    CError_ASSERT(1887,
+                                  IS_TYPE_POINTER_ONLY(TYPE_FUNC(ovfunc->obj->type)->functype) &&
+                                  IS_TYPE_CLASS(TPTR_TARGET(TYPE_FUNC(ovfunc->obj->type)->functype)));
+                    object = CClass_FindCovariantFunction(
+                        object,
+                        TPTR_TARGET(TYPE_FUNC(ovfunc->obj->type)->functype));
+                }
+
+                if ((offset26 = ovfunc->ovc8->offset - ovclass->offset)) {
+                    if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_8)) {
+                        cclass_ovbase = NULL;
+                        CError_ASSERT(1899, CClass_IsBaseOf(ovclass, ovfunc->ovc8));
+
+                        if (cclass_ovbase && (main_class->flags & CLASS_FLAGS_8000)) {
+                            offset23 = ovclass->offset - cclass_ovbase->offset;
+                            offset23 = CABI_GetCtorOffsetOffset(cclass_ovbase->tclass, NULL) - offset23;
+                            CError_ASSERT(1906, offset23 > 0);
+                            object = CClass_ThunkObject(object, offset26, 0, offset23);
+                        } else {
+                            object = CClass_ThunkObject(object, offset26, 0, -1);
+                        }
+                    }
+                }
+            } else {
+                object = ovfunc->obj;
+            }
+
+            if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_8)) {
+                link = lalloc(sizeof(OLinkList));
+                link->next = vtable_object_links;
+                link->obj = object;
+                link->offset = offset27;
+                link->somevalue = 0;
+                vtable_object_links = link;
+                vtable_object_data[offset27] = 1;
+            }
+        }
+    }
+
+    ovclass->alloced_vtable = 1;
+
+    for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next)
+        CClass_AllocVTableRec(ovbase->ovclass);
+}
+
+static Object *CClass_CheckClass(OVClass *ovclass, Boolean errorflag) {
+    Object *object;
+    Object *check;
+    OVFunc *ovfunc;
+    OVClassBase *ovbase;
+
+    object = NULL;
+
+    for (ovfunc = ovclass->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+        if (ovfunc->ovf10 && errorflag)
+            CError_Error(CErrorStr251, main_class, 0, ovfunc->obj, ovfunc->ovfC->obj, ovfunc->ovf10->obj);
+
+        if (!object) {
+            check = ovfunc->ovfC ? ovfunc->ovfC->obj : ovfunc->obj;
+            if (TYPE_FUNC(check->type)->flags & FUNC_FLAGS_8)
+                object = check;
+        }
+    }
+
+    for (ovbase = ovclass->bases; ovbase; ovbase = ovbase->next) {
+        if (object)
+            CClass_CheckClass(ovbase->ovclass, errorflag);
+        else
+            object = CClass_CheckClass(ovbase->ovclass, errorflag);
+    }
+
+    return object;
+}
+
+static void CClass_AllocVTable(TypeClass *tclass) {
+    OVClass *ovclass;
+
+    main_class = tclass;
+    ovclass = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+    cclass_root = ovclass;
+    CClass_OverrideOVClassTree(ovclass);
+    CClass_CheckClass(ovclass, 1);
+    CClass_AllocVTableRec(ovclass);
+}
+
+static Object *CClass_CheckVirtuals(TypeClass *tclass) {
+    OVClass *ovclass;
+
+    main_class = tclass;
+    ovclass = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+    cclass_root = ovclass;
+    CClass_OverrideOVClassTree(ovclass);
+    return CClass_CheckClass(ovclass, 0);
+}
+
+static void CClass_CheckVirtualBaseOverrides(OVClass *a, OVClass *b, Boolean flag) {
+    VClassList *vbase;
+    OVFunc *ovfunc;
+    OVClassBase *ovbase;
+
+    if (flag) {
+        for (ovfunc = b->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+            if (ovfunc->ovfC) {
+                cclass_ovbase = NULL;
+                CError_ASSERT(2040, CClass_IsBaseOf(b, ovfunc->ovc8));
+
+                if (cclass_ovbase) {
+                    for (vbase = a->tclass->vbases; vbase; vbase = vbase->next) {
+                        if (vbase->base == cclass_ovbase->tclass)
+                            break;
+                    }
+
+                    CError_ASSERT(2047, vbase);
+                    vbase->has_override = 1;
+                }
+            }
+        }
+    }
+
+    for (ovbase = b->bases; ovbase; ovbase = ovbase->next) {
+        CClass_CheckVirtualBaseOverrides(a, ovbase->ovclass, flag || ovbase->is_virtual);
+    }
+}
+
+static void CClass_CheckHideVirtual(OVClass *a, OVClass *b) {
+    OVClassBase *ovbase;
+    OVFunc *ovfunc;
+    Object *foundObject;
+    Boolean isAlias;
+    Object *object;
+    CScopeObjectIterator iter;
+
+    if (a != b) {
+        for (ovfunc = b->vfuncs; ovfunc; ovfunc = ovfunc->next) {
+            if (ovfunc->ovc8 != a) {
+                foundObject = NULL;
+                isAlias = 0;
+                CScope_InitObjectIterator(&iter, a->tclass->nspace);
+
+                while (1) {
+                    if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+                        break;
+
+                    if (object->name == ovfunc->obj->name && IS_TYPE_FUNC(object->type)) {
+                        if (object->datatype != DALIAS) {
+                            if (!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_20))
+                                foundObject = object;
+                        } else {
+                            if (object->u.alias.object == ovfunc->obj) {
+                                // don't show a warning if this is just an alias to the base function
+                                isAlias = 1;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                if (foundObject && !isAlias)
+                    CError_Warning(CErrorStr225, foundObject, ovfunc->obj);
+            }
+        }
+    }
+
+    for (ovbase = b->bases; ovbase; ovbase = ovbase->next)
+        CClass_CheckHideVirtual(a, ovbase->ovclass);
+}
+
+void CClass_CheckOverrides(TypeClass *tclass) {
+    OVClass *tree;
+    Object *object;
+    ObjectList *objlist;
+    ClassList *base;
+    VClassList *vbase;
+    int i;
+    CScopeObjectIterator iter;
+
+    i = 0;
+    for (base = tclass->bases; base; base = base->next) {
+        base->offset = i;
+        base->voffset = i;
+        i++;
+    }
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        vbase->offset = i;
+        vbase->voffset = i;
+        i++;
+    }
+
+    main_class = tclass;
+    tree = CClass_BuildOVClassTree(NULL, tclass, 0, 0);
+    cclass_root = tree;
+
+    CClass_OverrideOVClassTree(tree);
+    if (CClass_CheckClass(tree, 0))
+        tclass->flags |= CLASS_FLAGS_ABSTRACT;
+
+    if (copts.warn_hidevirtual)
+        CClass_CheckHideVirtual(tree, tree);
+
+    if (tclass->flags & CLASS_FLAGS_8000)
+        CClass_CheckVirtualBaseOverrides(tree, tree, 0);
+
+    objlist = NULL;
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (object->datatype == DVFUNC) {
+            CError_ASSERT(2175, IS_TYPE_FUNC(object->type));
+            if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_400000)
+                objlist = CClass_DeclareCovariantFuncs(objlist, object, tclass);
+        }
+    }
+
+    while (objlist) {
+        CScope_AddObject(tclass->nspace, objlist->object->name, OBJ_BASE(objlist->object));
+        objlist = objlist->next;
+    }
+
+    for (base = tclass->bases; base; base = base->next) {
+        base->offset = 0;
+        base->voffset = 0;
+    }
+    for (vbase = tclass->vbases; vbase; vbase = vbase->next) {
+        vbase->offset = 0;
+        vbase->voffset = 0;
+    }
+}
+
+static void CClass_FindDominator(TypeClass *tclass1, SInt32 offset1, Object *object1, TypeClass *tclass2, SInt32 offset2, TypeClass *tclass3) {
+    Object *object;
+    ClassList *base;
+    CScopeObjectIterator iter;
+
+    CScope_InitObjectIterator(&iter, tclass1->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (
+            object->name == cclass_dominator_vobject->name &&
+            object->datatype == DVFUNC &&
+            CClass_GetOverrideKind(TYPE_FUNC(cclass_dominator_vobject->type), TYPE_FUNC(object->type), 0)
+            )
+        {
+            if (object == cclass_dominator_vobject && offset1 == cclass_dominator_voffset) {
+                if (object1) {
+                    if (cclass_dominator_oobject && cclass_dominator_ooffset != offset2) {
+                        if (CClass_ClassDominates(cclass_dominator_oclass, tclass2))
+                            return;
+                        if (!CClass_ClassDominates(tclass2, cclass_dominator_oclass)) {
+                            cclass_dominator_eobject = object1;
+                            cclass_vbase = tclass3;
+                            return;
+                        }
+                    }
+
+                    cclass_dominator_oobject = object1;
+                    cclass_dominator_ooffset = offset2;
+                    cclass_dominator_oclass = tclass2;
+                    cclass_dominator_eobject = NULL;
+                    cclass_vbase = tclass3;
+                }
+                return;
+            } else {
+                if (!object1) {
+                    object1 = object;
+                    tclass2 = tclass1;
+                    offset2 = offset1;
+                }
+                break;
+            }
+        }
+    }
+
+    for (base = tclass1->bases; base; base = base->next) {
+        if (base->base->vtable) {
+            if (!base->is_virtual) {
+                CClass_FindDominator(base->base, offset1 + base->offset, object1, tclass2, offset2, tclass3);
+            } else {
+                SInt32 vboffset = CClass_VirtualBaseOffset(main_class, base->base);
+                CClass_FindDominator(base->base, vboffset, object1, tclass2, offset2, base->base);
+            }
+        }
+    }
+}
+
+static void CClass_ConstructVTable(TypeClass *tclass, SInt32 voffset, SInt32 offset, TypeClass *baseclass) {
+    Object *object;
+    Object *thunkobject;
+    SInt32 newoffset;
+    SInt32 newvoffset;
+    ClassList *base;
+    SInt32 thunkoffset;
+    OLinkList *olink;
+    CScopeObjectIterator iter;
+
+    CScope_InitObjectIterator(&iter, tclass->nspace);
+    while (1) {
+        if (!(object = OBJECT(CScope_NextObjectIteratorObject(&iter))))
+            break;
+
+        if (object->datatype == DVFUNC) {
+            newoffset = voffset + TYPE_METHOD(object->type)->x1E + CABI_GetVTableOffset(tclass);
+            CError_ASSERT(2288, newoffset < vtable_data_size);
+
+            if (!vtable_object_data[newoffset]) {
+                cclass_dominator_vobject = object;
+                cclass_dominator_voffset = offset;
+                cclass_dominator_oobject = NULL;
+                cclass_dominator_ooffset = offset;
+                CClass_FindDominator(main_class, 0, NULL, NULL, 0, NULL);
+
+                if (cclass_dominator_oobject) {
+                    if (cclass_dominator_eobject)
+                        CError_Error(CErrorStr251, main_class, 0, cclass_dominator_vobject, cclass_dominator_oobject, cclass_dominator_eobject);
+                } else {
+                    cclass_dominator_oobject = object;
+                    cclass_vbase = NULL;
+                }
+
+                vtable_object_data[newoffset] = 1;
+
+                if (!(TYPE_FUNC(cclass_dominator_oobject->type)->flags & FUNC_FLAGS_8)) {
+                    if (!check_pures) {
+                        thunkobject = cclass_dominator_oobject;
+                        if ((thunkoffset = cclass_dominator_ooffset - offset)) {
+                            if (cclass_vbase && (main_class->flags & CLASS_FLAGS_8000)) {
+                                thunkobject = CClass_ThunkObject(cclass_dominator_oobject, thunkoffset, 0,
+                                                                 CABI_GetCtorOffsetOffset(cclass_vbase, tclass));
+                            } else {
+                                thunkobject = CClass_ThunkObject(cclass_dominator_oobject, thunkoffset, 0, -1);
+                            }
+                        }
+
+                        olink = lalloc(sizeof(OLinkList));
+                        olink->next = vtable_object_links;
+                        olink->obj = thunkobject;
+                        olink->offset = newoffset;
+                        olink->somevalue = 0;
+                        vtable_object_links = olink;
+                    }
+                } else {
+                    found_pure = cclass_dominator_oobject;
+                }
+            }
+        }
+    }
+
+    for (base = tclass->bases; base; base = base->next) {
+        if (base->base->vtable) {
+            if (base->is_virtual) {
+                newoffset = CClass_VirtualBaseOffset(main_class, base->base);
+                newvoffset = CClass_VirtualBaseVTableOffset(main_class, base->base);
+                    CClass_ConstructVTable(
+                    base->base,
+                    newvoffset,
+                    newoffset,
+                    base->base
+                    );
+            } else {
+                CClass_ConstructVTable(
+                    base->base,
+                    voffset + base->voffset,
+                    offset + base->offset,
+                    baseclass
+                );
+            }
+        }
+    }
+}
+
+void CClass_ClassDefaultFuncAction(TypeClass *tclass) {
+}
+
+void CClass_ClassAction(TypeClass *tclass) {
+    if (tclass->sominfo) {
+        CSOM_GenerateClassStructures(tclass);
+    } else if (tclass->vtable) {
+        vtable_data_size = tclass->vtable->size;
+        vtable_object_data = lalloc(vtable_data_size);
+        memclrw(vtable_object_data, vtable_data_size);
+
+        main_class = tclass;
+        vtable_object_links = NULL;
+        found_pure = NULL;
+        check_pures = 0;
+
+        CClass_AllocVTable(tclass);
+
+        memclrw(vtable_object_data, vtable_data_size);
+        if (copts.useRTTI && !(tclass->flags & (CLASS_FLAGS_10 | CLASS_FLAGS_2000)))
+            vtable_object_links = CRTTI_ConstructVTableHeaders(tclass, vtable_object_data, vtable_object_links);
+
+        CError_ASSERT(2492, tclass->vtable->object->type->size == tclass->vtable->size);
+        CInit_DeclareData(tclass->vtable->object, vtable_object_data, vtable_object_links, tclass->vtable->size);
+    }
+}
+
+void CClass_MakeStaticActionClass(TypeClass *tclass) {
+    if (tclass->vtable) {
+        tclass->vtable->object->sclass = TK_STATIC;
+        tclass->vtable->object->qual |= Q_20000;
+        if (!(tclass->vtable->object->flags & OBJECT_FLAGS_2)) {
+            CParser_NewCallBackAction(tclass->vtable->object, tclass);
+        } else if (cparamblkptr->isPrecompiling != 1) {
+            CParser_NewClassAction(tclass);
+        }
+    }
+}
+
+Object *CClass_CheckPures(TypeClass *tclass) {
+    return CClass_CheckVirtuals(tclass);
+}
+
+void CClass_MemberDef(Object *obj, TypeClass *tclass) {
+    switch (tclass->action) {
+        case CLASS_ACTION_0:
+            break;
+        case CLASS_ACTION_1:
+            if (IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_4)) {
+                if (obj->qual & Q_INLINE) {
+                    if (tclass->sominfo)
+                        CError_Error(CErrorStr280);
+                    tclass->action = CLASS_ACTION_0;
+                    CClass_MakeStaticActionClass(tclass);
+                } else if (cparamblkptr->isPrecompiling != 1) {
+                    CParser_NewClassAction(tclass);
+                }
+            }
+            break;
+        case CLASS_ACTION_2:
+            CError_FATAL(2682);
+            break;
+        case CLASS_ACTION_3:
+            break;
+        default:
+            CError_FATAL(2701);
+    }
+}
+
+Object *CClass_ThisSelfObject(void) {
+    ObjectList *list;
+
+    if (cscope_currentfunc && cscope_currentclass) {
+        if (cscope_currentclass->objcinfo) {
+            for (list = arguments; list; list = list->next) {
+                if (list->object->name == self_name_node)
+                    return list->object;
+            }
+            CError_Error(CErrorStr301);
+        } else {
+            if (cscope_is_member_func) {
+                for (list = arguments; list; list = list->next) {
+                    if (list->object->name == this_name_node)
+                        return list->object;
+                }
+            }
+            CError_Error(CErrorStr189);
+        }
+    }
+
+    CError_Error(copts.cplusplus ? CErrorStr189 : CErrorStr301);
+    return NULL;
+}
+
+ENode *CClass_CreateThisSelfExpr(void) {
+    Object *object;
+    ENode *expr;
+
+    if (!(object = CClass_ThisSelfObject()))
+        return NULL;
+
+    expr = create_objectrefnode(object);
+    expr->rtype = CDecl_NewPointerType(TYPE(cscope_currentclass));
+    expr = makemonadicnode(expr, EINDIRECT);
+    expr->data.monadic->rtype = CDecl_NewPointerType(expr->rtype);
+
+    return expr;
+}
+
+static AccessType CClass_BaseMemberAccess(BClassList *path, AccessType access) {
+    ClassList *base;
+
+    if (path->next) {
+        access = CClass_BaseMemberAccess(path->next, access);
+        switch (access) {
+            case ACCESSPRIVATE:
+            case ACCESSNONE:
+                return ACCESSNONE;
+        }
+
+        for (base = TYPE_CLASS(path->type)->bases; ; base = base->next) {
+            if (!base)
+                return ACCESSNONE;
+
+            if (base->base == TYPE_CLASS(path->next->type)) {
+                switch (base->access) {
+                    case ACCESSNONE:
+                        access = ACCESSNONE;
+                        break;
+                    case ACCESSPROTECTED:
+                        if (access == ACCESSPUBLIC)
+                            access = ACCESSPROTECTED;
+                        break;
+                    case ACCESSPRIVATE:
+                        if (access == ACCESSPRIVATE)
+                            access = ACCESSNONE;
+                        else
+                            access = ACCESSPRIVATE;
+                        break;
+                    case ACCESSPUBLIC:
+                        break;
+                }
+                break;
+            }
+        }
+    }
+
+    return access;
+}
+
+static Boolean CClass_CanAccess(BClassList *path, AccessType access) {
+    AccessType access2;
+    BClassList *scan;
+    BClassList *next;
+    TypeClass *prevclass;
+    TypeClass *tclass;
+    ClassList *base;
+    ClassFriend *cfriend;
+
+    tclass = TYPE_CLASS(path->type);
+    access2 = access;
+    if ((scan = path->next)) {
+        if (access2 != ACCESSPRIVATE) {
+            prevclass = tclass;
+            while (scan) {
+                for (base = prevclass->bases; base; base = base->next) {
+                    if (base->base == TYPE_CLASS(scan->type))
+                        break;
+                }
+
+                if (!base)
+                    return 0;
+
+                switch (base->access) {
+                    case ACCESSNONE:
+                        access2 = ACCESSNONE;
+                        break;
+                    case ACCESSPROTECTED:
+                        if (access2 == ACCESSPUBLIC)
+                            access2 = ACCESSPROTECTED;
+                        break;
+                    case ACCESSPRIVATE:
+                        if (access2 == ACCESSPRIVATE)
+                            access2 = ACCESSNONE;
+                        else
+                            access2 = ACCESSPRIVATE;
+                        break;
+                    case ACCESSPUBLIC:
+                        break;
+                }
+
+                prevclass = TYPE_CLASS(scan->type);
+                scan = scan->next;
+            }
+        } else {
+            access2 = ACCESSNONE;
+        }
+    }
+
+    if (access2 == ACCESSPUBLIC)
+        return 1;
+
+    if (access2 != ACCESSNONE) {
+        if (cscope_currentclass == tclass)
+            return 1;
+        if (cobjc_currentclass == tclass)
+            return 1;
+
+        for (cfriend = tclass->friends; cfriend; cfriend = cfriend->next) {
+            if (cfriend->isclass) {
+                if (cfriend->u.theclass == cscope_currentclass)
+                    return 1;
+            } else {
+                if (cfriend->u.obj == cscope_currentfunc)
+                    return 1;
+            }
+        }
+    }
+
+    for (scan = path; scan->next; scan = scan->next) {
+        if (CClass_CanAccess(scan->next, access)) {
+            if ((next = scan->next->next) || access != ACCESSPUBLIC) {
+                scan->next->next = NULL;
+                if (CClass_CanAccess(path, ACCESSPUBLIC)) {
+                    scan->next->next = next;
+                    return 1;
+                }
+                scan->next->next = next;
+            }
+        }
+    }
+
+    return 0;
+}
+
+void CClass_CheckPathAccess(BClassList *path, Object *obj, AccessType access) {
+    if (!CClass_CanAccess(path, access)) {
+        if (path && obj)
+            CError_Error(CErrorStr381, path->type, 0, obj);
+        else
+            CError_Error(CErrorStr187);
+    }
+}
+
+static BClassList *CClass_PathCleanup(BClassList *path, TypeClass *tclass) {
+    BClassList *first;
+    ClassList *base;
+
+    first = path;
+
+    while (1) {
+        if (!path->next) {
+            if (!tclass)
+                return first;
+            if (path->type == TYPE(tclass))
+                return first;
+            return NULL;
+        }
+
+        if (path->type != path->next->type) {
+            for (base = TYPE_CLASS(path->type)->bases; base; base = base->next) {
+                if (base->base == TYPE_CLASS(path->next->type))
+                    break;
+            }
+
+            if (base) {
+                path = path->next;
+            } else {
+                first = path = path->next;
+            }
+        } else {
+            path->next = path->next->next;
+        }
+    }
+}
+
+void CClass_CheckStaticAccess(BClassList *path, TypeClass *tclass, AccessType access) {
+    ClassFriend *cfriend;
+
+    if (path) {
+        path = CClass_PathCleanup(path, tclass);
+        if (path && path->next) {
+            if (!CClass_CanAccess(path, access))
+                CError_Error(CErrorStr187);
+            return;
+        }
+    }
+
+    switch (access) {
+        case ACCESSPUBLIC:
+            return;
+        case ACCESSPRIVATE:
+        case ACCESSPROTECTED:
+            if (tclass == cscope_currentclass)
+                return;
+
+            for (cfriend = tclass->friends; cfriend; cfriend = cfriend->next) {
+                if (cfriend->isclass) {
+                    if (cfriend->u.theclass == cscope_currentclass)
+                        return;
+                } else {
+                    if (cfriend->u.obj == cscope_currentfunc)
+                        return;
+                }
+            }
+        case ACCESSNONE:
+            CError_Warning(CErrorStr187);
+            return;
+        default:
+            CError_FATAL(3013);
+    }
+}
+
+void CClass_CheckObjectAccess(BClassList *path, Object *obj) {
+    short depth;
+    Boolean isambigbase;
+
+    if (obj->nspace && obj->nspace->theclass) {
+        if (!path && cscope_currentclass)
+            path = CClass_GetBasePath(cscope_currentclass, obj->nspace->theclass, &depth, &isambigbase);
+
+        CClass_CheckStaticAccess(path, obj->nspace->theclass, obj->access);
+    }
+}
+
+void CClass_CheckEnumAccess(BClassList *path, ObjEnumConst *objec) {
+    if (path) {
+        if ((path = CClass_PathCleanup(path, NULL))) {
+            if (!CClass_CanAccess(path, objec->access))
+                CError_Error(CErrorStr187);
+            return;
+        }
+    }
+
+    if (
+        objec->access != ACCESSPUBLIC &&
+        IS_TYPE_ENUM(objec->type) &&
+        TYPE_ENUM(objec->type)->nspace &&
+        TYPE_ENUM(objec->type)->nspace->theclass
+        )
+        CClass_CheckStaticAccess(NULL, TYPE_ENUM(objec->type)->nspace->theclass, objec->access);
+}
+
+static Type *CClass_PointerTypeCopy(Type *type) {
+    Type *copy;
+
+    switch (type->type) {
+        case TYPEPOINTER:
+        case TYPEARRAY:
+            copy = galloc(sizeof(TypePointer));
+            *TYPE_POINTER(copy) = *TYPE_POINTER(type);
+            TPTR_TARGET(copy) = CClass_PointerTypeCopy(TPTR_TARGET(copy));
+            return copy;
+        case TYPEMEMBERPOINTER:
+            copy = galloc(sizeof(TypeMemberPointer));
+            *TYPE_MEMBER_POINTER(copy) = *TYPE_MEMBER_POINTER(type);
+            return copy;
+        default:
+            return type;
+    }
+}
+
+Type *CClass_CombineClassAccessQualifiers(Type *type, UInt32 qual1, UInt32 qual2, UInt32 *outflags) {
+    Type *inner;
+
+    qual2 = qual2 & (Q_CONST | Q_VOLATILE);
+    if (qual1 & Q_MUTABLE)
+        qual2 &= ~Q_CONST;
+    qual1 = qual1 & (Q_CONST | Q_VOLATILE);
+
+    inner = type;
+    while (IS_TYPE_ARRAY(inner))
+        inner = TPTR_TARGET(inner);
+
+    switch (inner->type) {
+        case TYPEMEMBERPOINTER:
+        case TYPEPOINTER:
+            if (qual2) {
+                type = CClass_PointerTypeCopy(type);
+                inner = type;
+                while (IS_TYPE_ARRAY(inner))
+                    inner = TPTR_TARGET(inner);
+
+                switch (inner->type) {
+                    case TYPEPOINTER:
+                        TPTR_QUAL(inner) |= qual2;
+                        break;
+                    case TYPEMEMBERPOINTER:
+                        TYPE_MEMBER_POINTER(inner)->qual |= qual2;
+                        break;
+                    default:
+                        CError_FATAL(3125);
+                }
+            }
+            break;
+        default:
+            qual1 |= qual2;
+    }
+
+    *outflags = qual1;
+    return type;
+}
+
+static void CClass_OptimizeBitFieldAccess(Type **ptype, SInt32 *poffset) {
+    Type *innertype;
+    TypeBitfield *newtype;
+    short i;
+
+    innertype = TYPE_BITFIELD(*ptype)->bitfieldtype;
+    if (TYPE_BITFIELD(*ptype)->unkB == 8) {
+        switch (TYPE_BITFIELD(*ptype)->unkA) {
+            case 0:
+                i = 0;
+                break;
+            case 8:
+                i = 1;
+                break;
+            case 16:
+                i = 2;
+                break;
+            case 24:
+                i = 3;
+                break;
+            default:
+                i = -1;
+                break;
+        }
+
+        if (i >= 0) {
+            if (innertype->size != 1) {
+                if (is_unsigned(TYPE_BITFIELD(*ptype)->bitfieldtype))
+                    *ptype = TYPE(&stunsignedchar);
+                else
+                    *ptype = TYPE(&stsignedchar);
+            } else {
+                *ptype = innertype;
+            }
+            *poffset += i;
+            return;
+        }
+    }
+
+    if (TYPE_BITFIELD(*ptype)->unkB == 16) {
+        switch (TYPE_BITFIELD(*ptype)->unkA) {
+            case 0:
+                i = 0;
+                break;
+            case 16:
+                i = 2;
+                break;
+            default:
+                i = -1;
+                break;
+        }
+
+        if (i >= 0) {
+            if (innertype->size != stsignedshort.size) {
+                if (is_unsigned(innertype))
+                    *ptype = TYPE(&stunsignedshort);
+                else
+                    *ptype = TYPE(&stsignedshort);
+            } else {
+                *ptype = innertype;
+            }
+            *poffset += i;
+            return;
+        }
+    }
+
+    if (TYPE_BITFIELD(*ptype)->unkB == 32 && TYPE_BITFIELD(*ptype)->unkA == 0) {
+        if (innertype->size != stsignedlong.size) {
+            if (is_unsigned(innertype))
+                *ptype = TYPE(&stunsignedlong);
+            else
+                *ptype = TYPE(&stsignedlong);
+        } else {
+            *ptype = innertype;
+        }
+        return;
+    }
+
+    if ((*ptype)->size != stsignedchar.size) {
+        i = TYPE_BITFIELD(*ptype)->unkA + TYPE_BITFIELD(*ptype)->unkB - 1;
+
+        if (TYPE_BITFIELD(*ptype)->unkB < 8 && (TYPE_BITFIELD(*ptype)->unkA & 0xFFF8) == (i & 0xFFF8)) {
+            newtype = galloc(sizeof(TypeBitfield));
+            *newtype = *TYPE_BITFIELD(*ptype);
+            *ptype = TYPE(newtype);
+
+            i = 0;
+            if (newtype->unkA >= 8)
+                i = 1;
+            if (newtype->unkA >= 16)
+                i = 2;
+            if (newtype->unkA >= 24)
+                i = 3;
+            *poffset += i;
+            newtype->unkA -= 8 * i;
+
+            newtype->bitfieldtype = is_unsigned(innertype) ? TYPE(&stunsignedchar) : TYPE(&stsignedchar);
+            newtype->size = newtype->bitfieldtype->size;
+            return;
+        }
+
+        if ((*ptype)->size != stsignedshort.size) {
+            if (TYPE_BITFIELD(*ptype)->unkB < 16 && (TYPE_BITFIELD(*ptype)->unkA & 0xFFF0) == (i & 0xFFF0)) {
+                newtype = galloc(sizeof(TypeBitfield));
+                *newtype = *TYPE_BITFIELD(*ptype);
+                *ptype = TYPE(newtype);
+
+                i = 0;
+                if (newtype->unkA >= 16)
+                    i = stsignedshort.size;
+                *poffset += i;
+                newtype->unkA -= 8 * i;
+
+                newtype->bitfieldtype = is_unsigned(innertype) ? TYPE(&stunsignedshort) : TYPE(&stsignedshort);
+                newtype->size = newtype->bitfieldtype->size;
+                return;
+            }
+        }
+    }
+}
+
+ENode *CClass_AccessMember(ENode *classexpr, Type *type, UInt32 qual, SInt32 offset) {
+    Type *innertype;
+    UInt32 flags;
+
+    innertype = NULL;
+
+    if (IS_TYPE_CLASS(classexpr->rtype) && (TYPE_CLASS(classexpr->rtype)->flags & CLASS_FLAGS_1)) {
+        classexpr = makemonadicnode(classexpr, EINDIRECT);
+        classexpr->data.monadic->rtype = CDecl_NewPointerType(classexpr->rtype);
+    }
+
+    if (IS_TYPE_BITFIELD(type)) {
+        innertype = TYPE_BITFIELD(type)->bitfieldtype;
+        CClass_OptimizeBitFieldAccess(&type, &offset);
+    }
+
+    if (offset && !canadd(classexpr->data.monadic, offset)) {
+        classexpr->data.monadic = makediadicnode(
+            classexpr->data.monadic,
+            intconstnode(TYPE(&stunsignedlong), offset),
+            EADD);
+        optimizecomm(classexpr->data.monadic);
+    }
+
+    if (innertype) {
+        if (IS_TYPE_BITFIELD(type)) {
+            classexpr->data.monadic = makemonadicnode(classexpr->data.monadic, EBITFIELD);
+            classexpr->data.monadic->rtype = type;
+            classexpr->rtype = TYPE_BITFIELD(type)->bitfieldtype;
+        } else {
+            classexpr->rtype = type;
+        }
+    } else {
+        classexpr->rtype = type;
+    }
+
+    classexpr->rtype = CClass_CombineClassAccessQualifiers(classexpr->rtype, qual, ENODE_QUALS(classexpr), &flags);
+    classexpr->flags = flags;
+    return classexpr;
+}
diff --git a/compiler_and_linker/unsorted/CDecl.c b/compiler_and_linker/unsorted/CDecl.c
index 63f2d0f..0ee3cf8 100644
--- a/compiler_and_linker/unsorted/CDecl.c
+++ b/compiler_and_linker/unsorted/CDecl.c
@@ -1,68 +1,30 @@
 #include "compiler/CDecl.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/CError.h"
-#include "compiler/objects.h"
-#include "compiler/scopes.h"
-#include "compiler/templates.h"
-#include "compiler/tokens.h"
-#include "compiler/CPrep.h"
-#include "compiler/CPrepTokenizer.h"
-#include "compiler/CMangler.h"
+#include "compiler/CABI.h"
+#include "compiler/CBrowse.h"
 #include "compiler/CClass.h"
-#include "compiler/CParser.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
 #include "compiler/CFunc.h"
 #include "compiler/CInit.h"
+#include "compiler/CInline.h"
 #include "compiler/CInt64.h"
-#include "compiler/CExpr.h"
 #include "compiler/CMachine.h"
-#include "compiler/CInline.h"
-#include "compiler/CABI.h"
-
-// TODO MOVE ME
-extern void CExcept_ScanExceptionSpecification(TypeFunc *tfunc);
-extern void CExcept_CompareSpecifications(ExceptSpecList *a, ExceptSpecList *b);
-extern void CObjC_ParseDefs(TypeStruct *tstruct);
-extern void CTempl_Parse(TypeClass *tclass, short access);
-extern Boolean CTempl_InstantiateTemplateClass(TemplClass *cls);
-extern Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type);
-extern TemplClass *CTemplTool_GetSelfRefTemplate(Type *type);
-extern Type *CTemplTool_ResolveMemberSelfRefs(TypeClass *tclass, Type *type, UInt32 *qual);
-extern Boolean CTempl_IsQualifiedMember(DeclInfo *declinfo, Type *type, NameSpace **nspace);
-extern Object *CTempl_TemplateFunctionCheck(DeclInfo *declinfo, NameSpaceObjectList *list);
-extern TemplArg *CTempl_ParseUncheckTemplArgs(void *a, Boolean flag);
-extern TemplArg *CTemplTool_MakeGlobalTemplArgCopy(TemplArg *args);
-extern void CTemplClass_RegisterFriend(TemplClass *tmclass, DeclInfo *declinfo);
-extern void CTemplClass_RegisterBaseClass(TemplClass *tmclass, Type *baseclass, short access, Boolean is_virtual);
-extern void CTemplClass_RegisterObjectDef(TemplClass *tmclass, ObjBase *obj);
-extern void CTemplClass_RegisterObjectInit(TemplClass *tmclass, ObjBase *obj, ENode *expr);
-extern void CTemplClass_DefineMember(TemplClass *tmclass, Object *obj, FileOffsetInfo *fileoffset, TStream *stream);
-extern void CTemplClass_CompleteClass(TemplClass *templ, DeclE *decle);
-extern void CTemplClass_RegisterEnumType(TemplClass *tmclass, TypeEnum *tenum);
-extern void CTemplClass_RegisterEnumerator(TemplClass *tmclass, ObjEnumConst *oec, ENode *expr);
-extern TypeClass *CTemplClass_DefineNestedClass(TemplClass *tmclass, HashNameNode *name, short mode);
-extern void CSOM_FixNewDeleteFunctype(TypeFunc *tfunc);
-extern void CSOM_CheckFuncType(TypeFunc *tfunc);
-extern void CSOM_ClassComplete(TypeClass *tclass);
-extern void CSOM_MakeSOMClass(TypeClass *tclass);
-typedef struct BrowseStruct {
-    void *x0;
-    void *x4;
-    void *x8;
-    void *xC;
-} BrowseStruct;
-extern void CBrowse_BeginStruct(DeclInfo *declinfo, TypeStruct *type, BrowseStruct *bs);
-extern void CBrowse_EndStruct(SInt32 offset, BrowseStruct *bs);
-extern void CBrowse_AddStructMember(StructMember *member, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_BeginClass(DeclInfo *declinfo, BrowseStruct *bs);
-extern void CBrowse_EndClass(SInt32 offset, BrowseStruct *bs);
-extern void CBrowse_NewTypedef(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, SInt32 tokenline, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewData(Object *obj, CPrepFileInfo *file, SInt32 tokenline, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewFunction(Object *obj, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewEnum(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_NewEnumConstant(NameSpace *nspace, HashNameNode *name, CPrepFileInfo *file, CPrepFileInfo *file2, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberData(Object *obj, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberFunction(Object *obj, SInt32 tokenoffset, SInt32 fileoffset);
-extern void CBrowse_AddClassMemberVar(ObjMemberVar *obj, SInt32 tokenoffset, SInt32 fileoffset);
+#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateClass.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/templates.h"
+#include "compiler/tokens.h"
 
 AccessType global_access;
 FileOffsetInfo member_fileoffset;
@@ -213,7 +175,7 @@ void CDecl_CompleteType(Type *type) {
     }
 
     if ((TYPE_CLASS(type)->flags & (CLASS_FLAGS_2 | CLASS_FLAGS_800)) == CLASS_FLAGS_800)
-        CTempl_InstantiateTemplateClass(TEMPL_CLASS(type));
+        CTempl_InstantiateTemplateClass(TYPE_CLASS(type));
 }
 
 Boolean IsCompleteType(Type *type) {
@@ -231,8 +193,14 @@ Boolean IsCompleteType(Type *type) {
             }
             return 1;
         case TYPECLASS:
-            if (!(TYPE_CLASS(type)->flags & CLASS_FLAGS_2) && (!(TYPE_CLASS(type)->flags & CLASS_FLAGS_800) || !CTempl_InstantiateTemplateClass(
-                    TEMPL_CLASS(type)))) {
+            if (
+                !(TYPE_CLASS(type)->flags & CLASS_FLAGS_2) &&
+                (
+                    !(TYPE_CLASS(type)->flags & CLASS_FLAGS_800) ||
+                    !CTempl_InstantiateTemplateClass(TYPE_CLASS(type))
+                    )
+                    )
+            {
                 CError_Error(136, type, 0);
                 return 0;
             }
@@ -418,7 +386,7 @@ void CDecl_ParseDirectFuncDecl(DeclInfo *declinfo) {
 
     if (copts.cplusplus) {
         CDecl_ParseCPPFuncDecl(tfunc);
-        if (declinfo->storageclass == OBJECT_SCLASS_104 && tfunc->exspecs)
+        if (declinfo->storageclass == TK_TYPEDEF && tfunc->exspecs)
             CError_Error(264);
     }
 
@@ -638,11 +606,13 @@ static Boolean CDecl_IsEnumClassTypeOrRef(Type *type) {
     return IS_TYPE_CLASS(type) || IS_TYPE_ENUM(type);
 }
 
-#define OpMysteryValue0 0
-#define OpMysteryValue1 1
-#define OpMysteryValue2 2
-#define OpMysteryValue3 3
-#define OpMysteryValue4 4
+typedef enum OpMysteryValue {
+    OpMysteryValue0 = 0,
+    OpMysteryValue1 = 1,
+    OpMysteryValue2 = 2,
+    OpMysteryValue3 = 3,
+    OpMysteryValue4 = 4
+} OpMysteryValue;
 
 static Boolean CDecl_CheckOperatorType(DeclInfo *declinfo, Boolean flag) {
     FuncArg *args;
@@ -675,7 +645,11 @@ static Boolean CDecl_CheckOperatorType(DeclInfo *declinfo, Boolean flag) {
 
             secondarg = args->next;
             if (secondarg) {
-                r27 = ((secondarg != &elipsis && !secondarg->next) != 0) ? OpMysteryValue4 : OpMysteryValue3;
+                //r27 = ((secondarg != &elipsis && !secondarg->next) != 0) ? OpMysteryValue2 : OpMysteryValue3;
+                if ((secondarg != &elipsis && !secondarg->next) != 0)
+                    r27 = OpMysteryValue2;
+                else
+                    r27 = OpMysteryValue3;
                 if (secondarg->dexpr) {
                     switch (declinfo->x3E) {
                         case '(':
@@ -1416,11 +1390,11 @@ void CheckDefaultArgs(FuncArg *args) {
 }
 
 static void CDecl_FuncRedeclCheck(Object *obj, DeclInfo *declinfo, Boolean flag) {
-    if (declinfo->storageclass == OBJECT_SCLASS_102 && obj->sclass != OBJECT_SCLASS_102) {
+    if (declinfo->storageclass == TK_STATIC && obj->sclass != TK_STATIC) {
         if (copts.cplusplus)
             CError_Error(260);
         else
-            obj->sclass = OBJECT_SCLASS_102;
+            obj->sclass = TK_STATIC;
     }
 
     obj->qual |= declinfo->qual;
@@ -1460,8 +1434,7 @@ Object *CDecl_GetFunctionObject(DeclInfo *declinfo, NameSpace *nspace, Boolean *
     }
 
     if (nspace2->theclass) {
-#line 1969
-        CError_ASSERT(declinfo->name);
+        CError_ASSERT(1969, declinfo->name);
         if (!nspace2->theclass->size)
             CDecl_CompleteType((Type *) nspace2->theclass);
         if (!(list = CScope_GetLocalObject(nspace2, declinfo->name))) {
@@ -1614,8 +1587,7 @@ void CDecl_TypedefDeclarator(DeclInfo *declinfo) {
                 CError_Error(322);
                 return;
             default:
-#line 2156
-                CError_FATAL();
+                CError_FATAL(2156);
         }
     }
 
@@ -1654,8 +1626,8 @@ void CDecl_TypedefDeclarator(DeclInfo *declinfo) {
         }
     }
 
-    if (cparamblkptr->browseOptions.recordTypedefs && declinfo->fileoffsetinfo.file->recordbrowseinfo)
-        CBrowse_NewTypedef(nspace, declinfo->name, declinfo->fileoffsetinfo.file, declinfo->fileoffsetinfo.tokenline, declinfo->fileoffsetinfo.tokenoffset, CPrep_BrowserFileOffset());
+    if (cparamblkptr->browseOptions.recordTypedefs && declinfo->file->recordbrowseinfo)
+        CBrowse_NewTypedef(nspace, declinfo->name, declinfo->file, declinfo->file2, declinfo->x60, CPrep_BrowserFileOffset());
 }
 
 static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag) {
@@ -1697,8 +1669,7 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
                 CError_Error(221);
                 break;
             default:
-#line 2281
-                CError_FATAL();
+                CError_FATAL(2281);
         }
     }
 
@@ -1706,24 +1677,24 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
         if (!flag)
             CDecl_CompleteType(declinfo->thetype);
         switch (declinfo->storageclass) {
-            case OBJECT_SCLASS_103:
+            case TK_EXTERN:
                 if (tk == '=' || tk == '(')
                     declinfo->storageclass = 0;
                 break;
             case 0:
                 if (CParser_IsConst(declinfo->thetype, declinfo->qual)) {
-                    if ((!obj && !nspace->theclass) || (obj && obj->sclass != OBJECT_SCLASS_103 && !obj->nspace->theclass))
-                        declinfo->storageclass = OBJECT_SCLASS_102;
+                    if ((!obj && !nspace->theclass) || (obj && obj->sclass != TK_EXTERN && !obj->nspace->theclass))
+                        declinfo->storageclass = TK_STATIC;
                 }
                 break;
         }
     } else {
-        if (declinfo->storageclass == OBJECT_SCLASS_103 && tk == '=')
+        if (declinfo->storageclass == TK_EXTERN && tk == '=')
             declinfo->storageclass = 0;
     }
 
     if (IS_TYPE_ARRAY(declinfo->thetype) && !declinfo->thetype->size && !declinfo->storageclass && tk != '=')
-        declinfo->storageclass = OBJECT_SCLASS_103;
+        declinfo->storageclass = TK_EXTERN;
 
     if (obj) {
         if ((!obj->type->size || !declinfo->thetype->size) && IS_TYPE_ARRAY(declinfo->thetype) && IS_TYPE_ARRAY(obj->type))
@@ -1740,8 +1711,8 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
             CError_Error(333, obj);
         }
 
-        if (declinfo->storageclass != OBJECT_SCLASS_103) {
-            if (obj->sclass != OBJECT_SCLASS_103 && declinfo->storageclass && obj->sclass != declinfo->storageclass)
+        if (declinfo->storageclass != TK_EXTERN) {
+            if (obj->sclass != TK_EXTERN && declinfo->storageclass && obj->sclass != declinfo->storageclass)
                 CError_Error(333, obj);
 
             if (tmpflag) {
@@ -1788,15 +1759,14 @@ static void CDecl_DataDeclarator(DeclInfo *declinfo, short access, Boolean flag)
             CInit_InitializeData(obj);
         }
 
-        if (declinfo->fileoffsetinfo.file->recordbrowseinfo && obj->sclass != OBJECT_SCLASS_103)
-            CBrowse_NewData(obj, declinfo->fileoffsetinfo.file, declinfo->fileoffsetinfo.tokenline, declinfo->fileoffsetinfo.tokenoffset, CPrep_BrowserFileOffset());
+        if (declinfo->file->recordbrowseinfo && obj->sclass != TK_EXTERN)
+            CBrowse_NewData(obj, declinfo->file, declinfo->file2, declinfo->x60, CPrep_BrowserFileOffset());
     } else if (tk == '=') {
         tk = lex();
         expr = CExpr_IntegralConstOrDepExpr();
         if (IS_TYPE_TEMPLATE(obj->type) || !ENODE_IS(expr, EINTCONST)) {
-#line 2426
-            CError_ASSERT(nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100));
-            CTemplClass_RegisterObjectInit(TEMPL_CLASS(nspace->theclass), OBJ_BASE(obj), expr);
+            CError_ASSERT(2426, nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100));
+            CTemplClass_RegisterObjectInit(TEMPL_CLASS(nspace->theclass), obj, expr);
         } else if ((obj->qual & Q_CONST) && IS_TYPE_INT_OR_ENUM(obj->type)) {
             obj->u.data.u.intconst = expr->data.intval;
             obj->qual |= Q_10000 | Q_20000;
@@ -1820,21 +1790,20 @@ Boolean CDecl_FunctionDeclarator(DeclInfo *declinfo, NameSpace *nspace, Boolean
             }
 
             if (obj->nspace == cscope_root && !strcmp(obj->name->name, "main")) {
-                if (obj->sclass == OBJECT_SCLASS_102 || (copts.ANSI_strict && TYPE_FUNC(obj->type)->functype != (Type *) &stsignedint))
+                if (obj->sclass == TK_STATIC || (copts.ANSI_strict && TYPE_FUNC(obj->type)->functype != (Type *) &stsignedint))
                     CError_Error(334);
-            } else if (copts.require_prototypes && (pflag || declinfo->fileoffsetinfo.is_inline)) {
-                if (obj->sclass != OBJECT_SCLASS_102 && !(obj->qual & Q_INLINE) && !obj->nspace->is_unnamed)
+            } else if (copts.require_prototypes && (pflag || declinfo->x64)) {
+                if (obj->sclass != TK_STATIC && !(obj->qual & Q_INLINE) && !obj->nspace->is_unnamed)
                     CError_Warning(178);
             }
 
             CFunc_ParseFuncDef(obj, declinfo, NULL, 0, 0, NULL);
-            // WARNING: WEIRD FileOffsetInfo ALERT
-            if (declinfo->fileoffsetinfo.file->recordbrowseinfo)
+            if (declinfo->file->recordbrowseinfo)
                 CBrowse_NewFunction(
                         obj,
-                        declinfo->fileoffsetinfo.file,
-                        (CPrepFileInfo *) declinfo->fileoffsetinfo.tokenline,
-                        declinfo->fileoffsetinfo.tokenoffset,
+                        declinfo->file,
+                        declinfo->file2,
+                        declinfo->x60,
                         CPrep_BrowserFileOffset());
 
             if (copts.cplusplus && lookahead() == ';')
@@ -1851,11 +1820,9 @@ static void CDecl_ParseSpecialMember(DeclInfo *declinfo, Boolean flag) {
     NameSpace *r25;
 
     if (!(r28 = declinfo->x10)) {
-#line 2544
-        CError_ASSERT(declinfo->x14);
-        r28 = declinfo->x14->object;
-#line 2546
-        CError_ASSERT(r28->otype == OT_OBJECT);
+        CError_ASSERT(2544, declinfo->x14);
+        r28 = OBJECT(declinfo->x14->object);
+        CError_ASSERT(2546, r28->otype == OT_OBJECT);
     }
 
     if (!r28->nspace->theclass) {
@@ -1900,8 +1867,7 @@ static void CDecl_ParseSpecialMember(DeclInfo *declinfo, Boolean flag) {
             }
             return;
         } else if (TYPE_FUNC(r28->type)->flags & FUNC_FLAGS_40) {
-#line 2603
-            CError_FATAL();
+            CError_FATAL(2603);
 
             declinfo->thetype = TYPE_FUNC(r28->type)->functype;
             declinfo->qual |= TYPE_FUNC(r28->type)->qual;
@@ -1967,7 +1933,7 @@ void CDecl_ScanDeclarator(DeclInfo *declinfo) {
         return;
     }
 
-    if (declinfo->storageclass && declinfo->storageclass != OBJECT_SCLASS_103)
+    if (declinfo->storageclass && declinfo->storageclass != TK_EXTERN)
         CError_Error(177);
 
     if (IS_TYPE_FUNC(declinfo->thetype)) {
@@ -1983,7 +1949,7 @@ void CDecl_ScanDeclarator(DeclInfo *declinfo) {
 
     if (
             (declinfo->qual & ~(Q_ALIGNED_MASK | Q_OVERLOAD | Q_20000 | Q_PASCAL | Q_VOLATILE | Q_CONST)) ||
-                    (declinfo->storageclass == OBJECT_SCLASS_104 && (declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST)))
+                    (declinfo->storageclass == TK_TYPEDEF && (declinfo->qual & ~(Q_ALIGNED_MASK | Q_REFERENCE | Q_PASCAL | Q_VOLATILE | Q_CONST)))
             )
         CError_Error(176);
 }
@@ -2000,8 +1966,7 @@ void scandeclaratorlist(DeclInfo *declinfo) {
     }
 
     CScope_GetScope(&savescope);
-#line 2707
-    CError_ASSERT(declinfo->thetype);
+    CError_ASSERT(2707, declinfo->thetype);
 
     r28 = 1;
     while (1) {
@@ -2020,7 +1985,7 @@ void scandeclaratorlist(DeclInfo *declinfo) {
             break;
         }
 
-        if (declinfo->storageclass != OBJECT_SCLASS_104) {
+        if (declinfo->storageclass != TK_TYPEDEF) {
             if (IS_TYPE_FUNC(declinfo->thetype)) {
                 if (!CDecl_FunctionDeclarator(declinfo, NULL, r28, 1))
                     return;
@@ -2282,8 +2247,7 @@ static TypeEnum *CDecl_OldParseEnumList(TypeEnum *tenum, HashNameNode *name) {
                             CError_Error(154);
                         break;
                     default:
-#line 3071
-                        CError_FATAL();
+                        CError_FATAL(3071);
                 }
             } else {
                 switch (basetype->size) {
@@ -2307,8 +2271,7 @@ static TypeEnum *CDecl_OldParseEnumList(TypeEnum *tenum, HashNameNode *name) {
                     case 8:
                         break;
                     default:
-#line 3099
-                        CError_FATAL();
+                        CError_FATAL(3099);
                 }
             }
 
@@ -2378,9 +2341,6 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
     ObjEnumConst *oec2;
     Type *r26;
     int t;
-    CInt64 maximumU;
-    CInt64 unused;
-    CInt64 minimum, maximum;
 
     if (!copts.enumsalwaysint) {
         for (oec2 = tenum->enumlist; oec2; oec2 = oec2->next) {
@@ -2389,9 +2349,9 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
         }
 
         if (oec2) {
-            unused = cint64_zero;
-            minimum = cint64_zero;
-            maximum = cint64_zero;
+            CInt64 unused = cint64_zero;
+            CInt64 minimum = cint64_zero;
+            CInt64 maximum = cint64_zero;
             for (oec = tenum->enumlist; oec; oec = oec->next) {
                 if (CInt64_IsNegative(&oec->val) && !is_unsigned(oec->type)) {
                     if (CInt64_Less(oec->val, minimum))
@@ -2420,11 +2380,11 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
                     break;
             } while (1);
         } else {
-            maximumU = cint64_zero;
+            CInt64 val = cint64_zero;
 
             for (oec = tenum->enumlist; oec; oec = oec->next) {
-                if (CInt64_GreaterU(oec->val, maximumU))
-                    maximumU = oec->val;
+                if (CInt64_GreaterU(oec->val, val))
+                    val = oec->val;
             }
 
             t = 0;
@@ -2435,7 +2395,7 @@ void CDecl_ComputeUnderlyingEnumType(TypeEnum *tenum) {
                     CError_Error(154);
                     break;
                 }
-                if (CInt64_IsInURange(maximumU, r26->size))
+                if (CInt64_IsInURange(val, r26->size))
                     break;
             } while (1);
         }
@@ -2691,18 +2651,17 @@ void scanenum(DeclInfo *declinfo) {
                 declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, name));
             }
 
-            if (cparamblkptr->browseOptions.recordEnums && declinfo->fileoffsetinfo.file->recordbrowseinfo)
+            if (cparamblkptr->browseOptions.recordEnums && declinfo->file->recordbrowseinfo)
                 CBrowse_NewEnum(
                         cscope_current,
                         TYPE_ENUM(declinfo->thetype)->enumname,
-                        declinfo->fileoffsetinfo.file,
-                        (CPrepFileInfo *) declinfo->fileoffsetinfo.tokenline,
-                        declinfo->fileoffsetinfo.tokenoffset,
+                        declinfo->file,
+                        declinfo->file2,
+                        declinfo->x60,
                         CPrep_BrowserFileOffset());
             return;
         } else {
-#line 3851
-            CError_ASSERT(!copts.cplusplus || tk != ';');
+            CError_ASSERT(3851, !copts.cplusplus || tk != ';');
             tkidentifier = name;
         }
     }
@@ -2716,8 +2675,7 @@ void scanenum(DeclInfo *declinfo) {
             declinfo->thetype = type;
             return;
         } else {
-#line 3865
-            CError_ASSERT(pr.name_4);
+            CError_ASSERT(3865, pr.name_4);
             if ((tk = lex()) == '{') {
                 declinfo->thetype = TYPE(CDecl_ParseEnumList(NULL, pr.name_4));
                 return;
@@ -2759,7 +2717,7 @@ void CDecl_ScanStructDeclarator(BigDeclInfo *bde) {
         }
 
         if ((!copts.ANSI_strict || copts.c9x) && !bde->declinfo2.thetype->size && IS_TYPE_ARRAY(bde->declinfo2.thetype)) {
-            if (bde->declinfo2.storageclass != OBJECT_SCLASS_102 && bde->declinfo2.storageclass != OBJECT_SCLASS_104) {
+            if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
                 type = TYPE_POINTER(bde->declinfo2.thetype)->target;
                 while (IS_TYPE_ARRAY(type))
                     type = TYPE_POINTER(type)->target;
@@ -2771,7 +2729,7 @@ void CDecl_ScanStructDeclarator(BigDeclInfo *bde) {
                 }
             }
         } else {
-            if (bde->declinfo2.storageclass != OBJECT_SCLASS_102 && bde->declinfo2.storageclass != OBJECT_SCLASS_104) {
+            if (bde->declinfo2.storageclass != TK_STATIC && bde->declinfo2.storageclass != TK_TYPEDEF) {
                 if (!IS_TYPE_FUNC(bde->declinfo2.thetype) && !IsCompleteType(bde->declinfo2.thetype))
                     return;
             }
@@ -2885,8 +2843,7 @@ static void CDecl_LayoutStruct(TypeStruct *tstruct) {
             r23 = 1;
 
         if (!member->name) {
-#line 4064
-            CError_ASSERT(IS_TYPE_STRUCT(member->type));
+            CError_ASSERT(4064, IS_TYPE_STRUCT(member->type));
             innerbase = member->offset;
             innermember = TYPE_STRUCT(member->type)->members;
             r23 = 1;
@@ -3076,7 +3033,7 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
     HashNameNode *name;
     TypeStruct typecopy;
     Boolean add_to_browse;
-    BrowseStruct bs;
+    GList gl;
     SInt32 offset;
 
     if (copts.cplusplus) {
@@ -3127,8 +3084,8 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
         type = (Type *) CDecl_DefineStruct(NULL, structtype);
     }
 
-    if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->fileoffsetinfo.file->recordbrowseinfo))
-        CBrowse_BeginStruct(declinfo, TYPE_STRUCT(type), &bs);
+    if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->file->recordbrowseinfo))
+        CBrowse_BeginStruct(declinfo, TYPE_STRUCT(type), &gl);
 
     typecopy = *TYPE_STRUCT(type);
     tk = lex();
@@ -3137,7 +3094,7 @@ void scanstruct(DeclInfo *declinfo, short structtype) {
     declinfo->thetype = type;
 
     if (add_to_browse)
-        CBrowse_EndStruct(offset, &bs);
+        CBrowse_EndStruct(offset, &gl);
 }
 
 static void InlineFunctionObject(Object *obj, TypeClass *tclass) {
@@ -3243,14 +3200,12 @@ static void CDecl_AddFunctionMember(DeclE *decle, TypeClass *tclass, DeclInfo *d
         declinfo->thetype = (Type *) tfunc;
     } else {
         tfunc = TYPE_METHOD(declinfo->thetype);
-#line 4579
-        CError_ASSERT(!tclass->sominfo);
+        CError_ASSERT(4579, !tclass->sominfo);
     }
 
     CDecl_ExtractClassExportFlags(declinfo, tclass->eflags);
 
-#line 4597
-    CError_ASSERT(cscope_current == tclass->nspace);
+    CError_ASSERT(4597, cscope_current == tclass->nspace);
 
     if (list) {
         obj = CDecl_OverloadFunctionObject(list, declinfo, &outflag, flag4 ? OverloadMode1 : OverloadMode2, 0);
@@ -3491,7 +3446,7 @@ static void CDecl_ParseFriendDecl(TypeClass *tclass) {
                                 InlineFunctionObject(obj, tclass);
                             } else {
                                 if (!obj->sclass)
-                                    obj->sclass = OBJECT_SCLASS_103;
+                                    obj->sclass = TK_EXTERN;
                             }
                         }
                     } else {
@@ -3535,8 +3490,7 @@ static ObjMemberVar *CDecl_InstanceDataDeclarator(DeclE *decle, TypeClass *tclas
             case OT_TYPETAG:
                 break;
             default:
-#line 4989
-                CError_FATAL();
+                CError_FATAL(4989);
         }
     }
 
@@ -3628,7 +3582,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                 }
             }
 
-            CTempl_Parse(tclass, access);
+            CTempl_Parse(TEMPL_CLASS(tclass), access);
             tk = lex();
             continue;
         }
@@ -3716,7 +3670,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                             scandeclarator(&bde.declinfo2);
                             if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
                                 if (r17)
-                                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(tclass, bde.declinfo2.thetype, &bde.declinfo2.qual);
+                                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
                                 if (tclass->sominfo) {
                                     if (TYPE_FUNC(bde.declinfo2.thetype)->args)
                                         CError_Error(272);
@@ -3856,9 +3810,9 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
         after_various_things:
         switch (bde.declinfo.storageclass) {
             case 0:
-            case OBJECT_SCLASS_102:
-            case OBJECT_SCLASS_104:
-            case OBJECT_SCLASS_12B:
+            case TK_STATIC:
+            case TK_TYPEDEF:
+            case TK_MUTABLE:
                 break;
             default:
                 CError_Error(177);
@@ -3869,11 +3823,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
             while (1) {
                 CDecl_ScanStructDeclarator(&bde);
                 if (r17)
-                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(tclass, bde.declinfo2.thetype, &bde.declinfo2.qual);
+                    bde.declinfo2.thetype = CTemplTool_ResolveMemberSelfRefs(TEMPL_CLASS(tclass), bde.declinfo2.thetype, &bde.declinfo2.qual);
                 if (bde.declinfo2.nspace)
                     CError_Error(200);
                 if (bde.declinfo2.x3E) {
-                    if (bde.declinfo.storageclass == OBJECT_SCLASS_12B)
+                    if (bde.declinfo.storageclass == TK_MUTABLE)
                         CError_QualifierCheck(Q_MUTABLE);
                     r19 = 0;
                     switch (bde.declinfo2.x3E) {
@@ -3888,7 +3842,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                             r19 = 1;
                             break;
                         default:
-                            if (bde.declinfo2.storageclass == OBJECT_SCLASS_102)
+                            if (bde.declinfo2.storageclass == TK_STATIC)
                                 CError_Error(193);
                             if (tclass->sominfo)
                                 CError_Error(193);
@@ -3908,11 +3862,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                     if (bde.declinfo2.name == constructor_name_node || bde.declinfo2.name == destructor_name_node)
                         CError_Error(241);
                     switch (bde.declinfo2.storageclass) {
-                        case OBJECT_SCLASS_104:
+                        case TK_TYPEDEF:
                             CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
                             CDecl_TypedefDeclarator(&bde.declinfo2);
                             break;
-                        case OBJECT_SCLASS_102:
+                        case TK_STATIC:
                             CError_QualifierCheck(bde.declinfo2.qual & Q_VIRTUAL);
                             if (tclass->sominfo)
                                 CError_Error(271);
@@ -3929,11 +3883,11 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                             }
                             break;
                         case 0:
-                        case OBJECT_SCLASS_12B:
+                        case TK_MUTABLE:
                             if (IS_TYPE_FUNC(bde.declinfo2.thetype)) {
                                 if (bde.declinfo2.name == tclass->classname)
                                     CError_Error(241);
-                                if (bde.declinfo.storageclass == OBJECT_SCLASS_12B)
+                                if (bde.declinfo.storageclass == TK_MUTABLE)
                                     CError_QualifierCheck(Q_MUTABLE);
                                 bde.declinfo2.qual |= r21;
                                 CDecl_AddFunctionMember(decle, tclass, &bde.declinfo2, access, 1, 0, 1, 0);
@@ -3941,7 +3895,7 @@ static void CDecl_ParseClassMembers(DeclE *decle, TypeClass *tclass, short mode)
                                 CDecl_CompleteType(bde.declinfo2.thetype);
                                 CanCreateObject(bde.declinfo2.thetype);
                                 CError_QualifierCheck(bde.declinfo2.qual & (Q_VIRTUAL | Q_INLINE));
-                                if (bde.declinfo2.storageclass == OBJECT_SCLASS_12B)
+                                if (bde.declinfo2.storageclass == TK_MUTABLE)
                                     bde.declinfo2.qual |= Q_MUTABLE;
                                 CDecl_InstanceDataDeclarator(decle, tclass, bde.declinfo2.thetype, bde.declinfo2.qual, bde.declinfo2.name, access);
                             }
@@ -4236,17 +4190,14 @@ static void CDecl_ParseBaseClassList(TypeClass *tclass, short mode, Boolean is_t
     }
 }
 
-static short getaccesstype(short a, short b, short c) {
-    AccessType a1 = (AccessType) a;
-    AccessType b1 = (AccessType) b;
-    AccessType c1 = (AccessType) c;
-
-    if (a1 == ACCESSNONE || b1 == ACCESSNONE || b1 == ACCESSPRIVATE)
+static short getaccesstype(AccessType a, AccessType b, AccessType c) {
+    if (a == ACCESSNONE || b == ACCESSNONE || b == ACCESSPRIVATE)
         return ACCESSNONE;
-    else if (c1 == ACCESSPUBLIC && a1 != ACCESSPUBLIC)
+
+    if (c == ACCESSPUBLIC && b != ACCESSPUBLIC)
         return ACCESSNONE;
-    else
-        return ACCESSPUBLIC;
+
+    return ACCESSPUBLIC;
 }
 
 static TypeMethod *CDecl_MakeDefaultCtorType(TypeClass *tclass) {
@@ -4566,8 +4517,7 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
 
         i = TYPE_METHOD(obj->type)->x1E;
         if (i > 0) {
-#line 6363
-            CError_ASSERT((i - 1) < decle->x8 && !objbuf[(int) (i - 1)]);
+            CError_ASSERT(6363, (i - 1) < decle->x8 && !objbuf[(int) (i - 1)]);
             objbuf[(int) (i - 1)] = OBJ_BASE(obj);
             index++;
             if (obj->datatype != DVFUNC && !TYPE_METHOD(obj->type)->x26 && CClass_OverridesBaseMember(tclass, obj->name, obj))
@@ -4587,8 +4537,7 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
                 TYPE_FUNC(obj->type)->flags &= ~FUNC_FLAGS_8;
             }
         } else {
-#line 6412
-            CError_ASSERT(i == 0);
+            CError_ASSERT(6412, i == 0);
         }
 
         if (!tclass->sominfo)
@@ -4609,19 +4558,16 @@ static void CDecl_SetupClassLayout(DeclE *decle, TypeClass *tclass, ObjBase **ob
     if (!tclass->sominfo) {
         for (i = 0, ivar = tclass->ivars; i < decle->x8; i++) {
             if (!objbuf[i]) {
-#line 6449
-                CError_ASSERT(ivar);
+                CError_ASSERT(6449, ivar);
                 objbuf[i] = OBJ_BASE(ivar);
                 ivar = ivar->next;
                 index++;
             }
         }
-#line 6455
-        CError_ASSERT(ivar == NULL);
+        CError_ASSERT(6455, ivar == NULL);
     }
 
-#line 6458
-    CError_ASSERT(index == decle->x8);
+    CError_ASSERT(6458, index == decle->x8);
 }
 
 void CDecl_CompleteClass(DeclE *decle, TypeClass *tclass) {
@@ -4660,9 +4606,8 @@ TypeClass *CDecl_DefineClass(NameSpace *nspace, HashNameNode *name, TypeClass *t
     ObjType *objtype;
 
     if (!tclass && nspace->theclass && (nspace->theclass->flags & CLASS_FLAGS_100)) {
-#line 6556
-        CError_ASSERT(!flag2);
-        return CTemplClass_DefineNestedClass(TEMPL_CLASS(nspace->theclass), name, mode);
+        CError_ASSERT(6556, !flag2);
+        return TYPE_CLASS(CTemplClass_DefineNestedClass(TEMPL_CLASS(nspace->theclass), name, mode));
     }
 
     mynspace = CScope_NewListNameSpace(name, 1);
@@ -4759,7 +4704,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
     NameSpace *nspace;
     CScopeParseResult pr;
     CScopeSave scopesave;
-    BrowseStruct bs;
+    GList gl;
     FileOffsetInfo offsetsave;
     SInt32 offset;
     Boolean is_templ;
@@ -4828,8 +4773,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
                     goto tagtype_search;
                 }
 
-#line 6786
-                CError_ASSERT(pr.name_4);
+                CError_ASSERT(6786, pr.name_4);
 
                 tclass = CDecl_DefineClass(CScope_FindNonClassNonFunctionNS(cscope_current), pr.name_4, NULL, mode, 0, 1);
                 tclass->eflags |= class_declspec;
@@ -4865,8 +4809,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
                 TEMPL_CLASS_INST(tclass)->is_specialized = 1;
         }
 
-#line 6853
-        CError_ASSERT(copts.align_mode >= 0 && copts.align_mode <= 14);
+        CError_ASSERT(6853, copts.align_mode >= 0 && copts.align_mode <= 14);
 
         tclass->eflags |= (UInt8) ((copts.align_mode + 1) << 4);
         if (tk == ':')
@@ -4875,9 +4818,9 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
         CScope_SetClassDefScope(tclass, &scopesave);
         if (tk == '{') {
             tk = lex();
-            if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->fileoffsetinfo.file->recordbrowseinfo)) {
+            if ((add_to_browse = cparamblkptr->browseOptions.recordClasses && declinfo->file->recordbrowseinfo)) {
                 offsetsave = member_fileoffset;
-                CBrowse_BeginClass(declinfo, &bs);
+                CBrowse_BeginClass(declinfo, &gl);
             }
             CDecl_ParseClassMembers(&decle, tclass, mode);
             offset = CPrep_BrowserFileOffset();
@@ -4887,7 +4830,7 @@ void CDecl_ParseClass(DeclInfo *declinfo, short mode, Boolean flag1, UInt8 class
                 member_fileoffset = offsetsave;
                 if (flag1 && tk == ';')
                     CPrep_BrowserFileOffset();
-                CBrowse_EndClass(offset, &bs);
+                CBrowse_EndClass(offset, &gl);
             }
         } else {
             CError_Error(135);
diff --git a/compiler_and_linker/unsorted/CError.c b/compiler_and_linker/unsorted/CError.c
index 40e237a..a7ade45 100644
--- a/compiler_and_linker/unsorted/CError.c
+++ b/compiler_and_linker/unsorted/CError.c
@@ -249,7 +249,6 @@ void CError_BufferAppendTemplDepType(CErrorBuffer *eb, TypeTemplDep *type) {
 }
 
 void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMethod) {
-    // not matching - weirdness with referencing string constants
     FuncArg *arg;
     UInt32 qual;
 
@@ -274,14 +273,14 @@ void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMe
             if (arg == &elipsis || arg == &oldstyle) {
                 CError_BufferAppendString(eb, "...");
                 break;
-            } else {
-                CError_BufferAppendType(eb, arg->type, arg->qual);
             }
 
-            if (!arg->next) {
+            CError_BufferAppendType(eb, arg->type, arg->qual);
+
+            if ((arg = arg->next))
                 CError_BufferAppendString(eb, ", ");
+            else
                 break;
-            }
         }
     }
     CError_BufferAppendChar(eb, ')');
@@ -291,73 +290,73 @@ void CError_BufferAppendFuncArgs(CErrorBuffer *eb, TypeFunc *tfunc, Boolean isMe
 
 void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
     // not matching - register issues
+    Type *scan;
+    Type *scan2;
     char buf[16];
-    Type *scan, *scan2;
 
     switch (ty->type) {
         case TYPEVOID:
             CError_BufferAppendQualifier(eb, qual);
             CError_BufferAppendString(eb, "void");
-            break;
+            return;
         case TYPEINT:
         case TYPEFLOAT:
             CError_BufferAppendQualifier(eb, qual);
             switch (TYPE_INTEGRAL(ty)->integral) {
                 case IT_BOOL:
                     CError_BufferAppendString(eb, "bool");
-                    break;
+                    return;
                 case IT_CHAR:
                     CError_BufferAppendString(eb, "char");
-                    break;
+                    return;
                 case IT_UCHAR:
                     CError_BufferAppendString(eb, "unsigned char");
-                    break;
+                    return;
                 case IT_SCHAR:
                     CError_BufferAppendString(eb, "signed char");
-                    break;
+                    return;
                 case IT_WCHAR_T:
                     CError_BufferAppendString(eb, "wchar_t");
-                    break;
+                    return;
                 case IT_SHORT:
                     CError_BufferAppendString(eb, "short");
-                    break;
+                    return;
                 case IT_USHORT:
                     CError_BufferAppendString(eb, "unsigned short");
-                    break;
+                    return;
                 case IT_INT:
                     CError_BufferAppendString(eb, "int");
-                    break;
+                    return;
                 case IT_UINT:
                     CError_BufferAppendString(eb, "unsigned int");
-                    break;
+                    return;
                 case IT_LONG:
                     CError_BufferAppendString(eb, "long");
-                    break;
+                    return;
                 case IT_ULONG:
                     CError_BufferAppendString(eb, "unsigned long");
-                    break;
+                    return;
                 case IT_LONGLONG:
                     CError_BufferAppendString(eb, "long long");
-                    break;
+                    return;
                 case IT_ULONGLONG:
                     CError_BufferAppendString(eb, "unsigned long long");
-                    break;
+                    return;
                 case IT_FLOAT:
                     CError_BufferAppendString(eb, "float");
-                    break;
+                    return;
                 case IT_SHORTDOUBLE:
                     CError_BufferAppendString(eb, "short double");
-                    break;
+                    return;
                 case IT_DOUBLE:
                     CError_BufferAppendString(eb, "double");
-                    break;
+                    return;
                 case IT_LONGDOUBLE:
                     CError_BufferAppendString(eb, "long double");
-                    break;
+                    return;
                 default:
                     CError_FATAL(584);
             }
-            break;
         case TYPEENUM:
             CError_BufferAppendQualifier(eb, qual);
             CError_BufferAppendNameSpace(eb, TYPE_ENUM(ty)->nspace);
@@ -365,7 +364,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
                 CError_BufferAppendString(eb, TYPE_ENUM(ty)->enumname->name);
             else
                 CError_BufferAppendString(eb, "{unnamed-enum}");
-            break;
+            return;
         case TYPESTRUCT:
             CError_BufferAppendQualifier(eb, qual);
             switch (TYPE_STRUCT(ty)->stype) {
@@ -373,7 +372,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
                     CError_BufferAppendString(eb, "struct ");
                     break;
                 case STRUCT_TYPE_UNION:
-                    CError_BufferAppendString(eb, "struct ");
+                    CError_BufferAppendString(eb, "union ");
                     break;
                 case STRUCT_TYPE_4:
                 case STRUCT_TYPE_5:
@@ -392,7 +391,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
             }
             if (TYPE_STRUCT(ty)->name)
                 CError_BufferAppendString(eb, TYPE_STRUCT(ty)->name->name);
-            break;
+            return;
         case TYPECLASS:
             CError_BufferAppendQualifier(eb, qual);
             CError_BufferAppendNameSpace(eb, TYPE_CLASS(ty)->nspace->parent);
@@ -406,7 +405,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
             } else {
                 CError_BufferAppendString(eb, "{unnamed-class}");
             }
-            break;
+            return;
         case TYPEPOINTER:
         case TYPEMEMBERPOINTER:
             scan = ty;
@@ -430,7 +429,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
                     CError_BufferAppendPType(eb, ty);
                     CError_BufferAppendChar(eb, ')');
                     CError_BufferAppendFuncArgs(eb, TYPE_FUNC(scan), ty->type == TYPEMEMBERPOINTER);
-                    break;
+                    return;
                 case TYPEARRAY:
                     scan2 = scan;
                     while (scan->type == TYPEARRAY)
@@ -445,7 +444,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
                     CError_BufferAppendType(eb, scan, 0);
                     CError_BufferAppendChar(eb, ' ');
                     CError_BufferAppendPType(eb, ty);
-                    break;
+                    return;
             }
             break;
         case TYPEFUNC:
@@ -455,7 +454,7 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
             CError_BufferAppendType(eb, TYPE_FUNC(ty)->functype, 0);
             CError_BufferAppendChar(eb, ' ');
             CError_BufferAppendFuncArgs(eb, TYPE_FUNC(ty), 0);
-            break;
+            return;
         case TYPEARRAY:
             CError_BufferAppendQualifier(eb, qual);
             scan = ty;
@@ -472,18 +471,18 @@ void CError_BufferAppendType(CErrorBuffer *eb, Type *ty, UInt32 qual) {
                 CError_BufferAppendChar(eb, ']');
                 ty = TYPE_POINTER(ty)->target;
             }
-            break;
+            return;
         case TYPETEMPLATE:
             CError_BufferAppendQualifier(eb, qual);
             CError_BufferAppendTemplDepType(eb, TYPE_TEMPLATE(ty));
-            break;
+            return;
         case TYPETEMPLDEPEXPR:
             CError_BufferAppendString(eb, "T");
-            break;
+            return;
         case TYPEBITFIELD:
             sprintf(buf, "bitfield:%ld", TYPE_BITFIELD(ty)->unkB);
             CError_BufferAppendString(eb, buf);
-            break;
+            return;
         default:
             CError_FATAL(752);
     }
@@ -740,56 +739,58 @@ void CError_ErrorMessageVA(int code, const char *format, va_list list, Boolean f
     SInt32 moddate;
     Type *type;
     UInt32 qual;
+    const char *p;
     CError_BufferInit(&eb, buf, sizeof(buf));
 
+    p = format;
     do {
-        switch (format[0]) {
+        switch (p[0]) {
             case 0:
                 break;
             case '%':
-                switch (format[1]) {
+                switch (p[1]) {
                     case 'n':
                         MWUnmangle(va_arg(list, const char *), unmangleBuf, sizeof(unmangleBuf));
                         CError_BufferAppendString(&eb, unmangleBuf);
-                        format += 2;
+                        p += 2;
                         continue;
                     case 'u':
                         CError_BufferAppendString(&eb, va_arg(list, const char *));
-                        format += 2;
+                        p += 2;
                         continue;
                     case 'o':
                         CError_AppendObjectName(&eb, va_arg(list, Object *));
-                        format += 2;
+                        p += 2;
                         continue;
                     case 'm':
                         CError_AppendMethodName(&eb, va_arg(list, ObjCMethod *));
-                        format += 2;
+                        p += 2;
                         continue;
                     case 't':
                         type = va_arg(list, Type *);
                         qual = va_arg(list, UInt32);
                         CError_BufferAppendType(&eb, type, qual);
-                        format += 2;
+                        p += 2;
                         continue;
                     case '%':
                         CError_BufferAppendChar(&eb, '%');
-                        format += 2;
+                        p += 2;
                         continue;
                     case 'i':
                         sprintf(unmangleBuf, "%ld", va_arg(list, SInt32));
                         CError_BufferAppendString(&eb, unmangleBuf);
-                        format += 2;
+                        p += 2;
                         continue;
                     case 'f':
                         CError_BufferAppendString(&eb, CTool_GetPathName(va_arg(list, FSSpec *), &moddate)->name);
-                        format += 2;
+                        p += 2;
                         continue;
                     default:
                         CError_FATAL(1174);
                 }
                 break;
             default:
-                CError_BufferAppendChar(&eb, *(format++));
+                CError_BufferAppendChar(&eb, *(p++));
                 continue;
         }
         break;
@@ -883,6 +884,8 @@ void CError_ErrorFuncCall(short code, NameSpaceObjectList *args, ENodeList *argN
                     CError_BufferAppendType(&eb, argscan->node->rtype, argscan->node->flags & ENODE_FLAG_QUALS);
                     if ((argscan = argscan->next))
                         CError_BufferAppendString(&eb, ", ");
+                    else
+                        break;
                 }
                 CError_BufferAppendChar(&eb, ')');
                 break;
@@ -964,15 +967,11 @@ void CError_AbstractClassError(TypeClass *tclass) {
 
 void CError_Warning(int code, ...) {
     va_list va;
-    if (trychain)
+    if (trychain || copts.supress_warnings)
         return;
 
-    if (copts.supress_warnings) {
-        va_start(va, code);
-    } else {
-        va_start(va, code);
-        CError_VAErrorMessage(code, va, 0, 1);
-    }
+    va_start(va, code);
+    CError_VAErrorMessage(code, va, 0, 1);
     va_end(va);
 }
 
diff --git a/compiler_and_linker/unsorted/CException.c b/compiler_and_linker/unsorted/CException.c
index 2fdd2d3..d8a100c 100644
--- a/compiler_and_linker/unsorted/CException.c
+++ b/compiler_and_linker/unsorted/CException.c
@@ -25,13 +25,6 @@ typedef struct UniqueObj {
     SInt32 uniqueid;
 } UniqueObj;
 
-typedef struct DtorTemp {
-    struct DtorTemp *next;
-    Object *object;
-    Object *dtor;
-    Object *temp;
-} DtorTemp;
-
 ExceptionAction *cexcept_dobjstack;
 Boolean cexcept_hasdobjects;
 Boolean cexcept_magic;
@@ -311,7 +304,7 @@ ENode *CExcept_RegisterDestructorObject(Object *local, SInt32 offset, Object *dt
     cexcept_dobjstack = action;
 
     expr = create_objectrefnode(local);
-    dtorObject = CABI_GetDestructorObject(dtor, 1);
+    dtorObject = CABI_GetDestructorObject(dtor, CABIDestroy1);
 
     if (offset == 0) {
         action->type = EAT_DESTROYLOCAL;
@@ -339,7 +332,7 @@ void CExcept_RegisterLocalArray(Statement *stmt, Object *localarray, Object *dto
     action->prev = cexcept_dobjstack;
     cexcept_dobjstack = action;
 
-    dtorObject = CABI_GetDestructorObject(dtor, 1);
+    dtorObject = CABI_GetDestructorObject(dtor, CABIDestroy1);
 
     action->type = EAT_DESTROYLOCALARRAY;
     action->data.destroy_local_array.localarray = localarray;
@@ -493,10 +486,10 @@ void CExcept_RegisterMember(Statement *stmt, Object *objectptr, SInt32 offset, O
     if (cond == NULL) {
         if (isMember) {
             action->type = EAT_DESTROYMEMBER;
-            action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, 1);
+            action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
         } else {
             action->type = EAT_DESTROYBASE;
-            action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, 0);
+            action->data.destroy_member.dtor = CABI_GetDestructorObject(dtor, CABIDestroy0);
         }
         action->data.destroy_member.objectptr = objectptr;
         action->data.destroy_member.offset = offset;
@@ -505,7 +498,7 @@ void CExcept_RegisterMember(Statement *stmt, Object *objectptr, SInt32 offset, O
         action->type = EAT_DESTROYMEMBERCOND;
         action->data.destroy_member_cond.objectptr = objectptr;
         action->data.destroy_member_cond.cond = cond;
-        action->data.destroy_member_cond.dtor = CABI_GetDestructorObject(dtor, 1);
+        action->data.destroy_member_cond.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
         action->data.destroy_member_cond.offset = offset;
     }
 
@@ -521,7 +514,7 @@ void CExcept_RegisterMemberArray(Statement *stmt, Object *objectptr, SInt32 offs
 
     action->type = EAT_DESTROYMEMBERARRAY;
     action->data.destroy_member_array.objectptr = objectptr;
-    action->data.destroy_member_array.dtor = CABI_GetDestructorObject(dtor, 1);
+    action->data.destroy_member_array.dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
     action->data.destroy_member_array.offset = offset;
     action->data.destroy_member_array.elements = elements;
     action->data.destroy_member_array.element_size = element_size;
@@ -537,7 +530,7 @@ static Statement *CExcept_DestroyLocal(ExceptionAction *ea, Statement *stmt, Obj
     if (offset)
         expr = makediadicnode(expr, intconstnode(TYPE(&stunsignedlong), offset), EADD);
 
-    expr = CABI_DestroyObject(dtor, expr, 1, 1, 0);
+    expr = CABI_DestroyObject(dtor, expr, CABIDestroy1, 1, 0);
 
     CError_ASSERT(687, expr->type == EFUNCCALL && expr->data.funccall.funcref->type == EOBJREF);
     if (expr->data.funccall.funcref->data.objref->datatype == DVFUNC)
@@ -565,7 +558,7 @@ static Statement *CExcept_DestroyLocalArray(ExceptionAction *ea, Statement *stmt
     newStmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
 
     if (dtor)
-        dtorExpr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+        dtorExpr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
     else
         dtorExpr = nullnode();
 
@@ -956,7 +949,7 @@ ENode *CExcept_ScanThrowExpression(void) {
                     Xthrw_func,
                     expr,
                     resultExpr,
-                    create_objectrefnode(CABI_GetDestructorObject(func, 1)),
+                    create_objectrefnode(CABI_GetDestructorObject(func, CABIDestroy1)),
                     NULL);
             } else {
                 expr = funccallexpr(
@@ -1318,7 +1311,7 @@ static ENode *CExcept_TempTrans_ETEMP(ENode *expr) {
         cexcept_eabefore = ea;
         ea->type = EAT_DESTROYLOCAL;
         ea->data.destroy_local.local = dtorTemp->object;
-        ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+        ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
 
         ea = lalloc(sizeof(ExceptionAction));
         *ea = *cexcept_eabefore;
@@ -1635,7 +1628,7 @@ static ENode *CExcept_TempTransFuncCall(ENode *expr, Boolean isCond) {
 
             ea->type = EAT_DESTROYLOCALCOND;
             ea->data.destroy_local_cond.local = dtorTemp->object;
-            ea->data.destroy_local_cond.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+            ea->data.destroy_local_cond.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
             ea->data.destroy_local_cond.cond = dtorTemp->temp;
 
             ea = lalloc(sizeof(ExceptionAction));
@@ -1653,7 +1646,7 @@ static ENode *CExcept_TempTransFuncCall(ENode *expr, Boolean isCond) {
 
             ea->type = EAT_DESTROYLOCAL;
             ea->data.destroy_local.local = dtorTemp->object;
-            ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, 1);
+            ea->data.destroy_local.dtor = CABI_GetDestructorObject(dtorTemp->dtor, CABIDestroy1);
 
             ea = lalloc(sizeof(ExceptionAction));
             *ea = *cexcept_eabefore;
@@ -1896,7 +1889,7 @@ static Statement *CExcept_DtorTransform(Statement *stmt) {
         }
 
         curStmt = CFunc_InsertStatement(ST_EXPRESSION, curStmt);
-        curStmt->expr = CABI_DestroyObject(dtorTemp->dtor, create_objectrefnode(dtorTemp->object), 1, 1, 0);
+        curStmt->expr = CABI_DestroyObject(dtorTemp->dtor, create_objectrefnode(dtorTemp->object), CABIDestroy1, 1, 0);
         curStmt->dobjstack = cexcept_eaafter;
 
         if (dtorTemp->temp) {
diff --git a/compiler_and_linker/unsorted/CExpr.c b/compiler_and_linker/unsorted/CExpr.c
index 425a004..f305fc9 100644
--- a/compiler_and_linker/unsorted/CExpr.c
+++ b/compiler_and_linker/unsorted/CExpr.c
@@ -3,16 +3,25 @@
 #include "compiler/CClass.h"
 #include "compiler/CDecl.h"
 #include "compiler/CError.h"
+#include "compiler/CException.h"
 #include "compiler/CInit.h"
 #include "compiler/CInline.h"
+#include "compiler/CIRTransform.h"
 #include "compiler/CMachine.h"
 #include "compiler/CMangler.h"
 #include "compiler/CInt64.h"
+#include "compiler/CObjC.h"
+#include "compiler/CObjCModern.h"
 #include "compiler/CParser.h"
 #include "compiler/CPrep.h"
 #include "compiler/CPrepTokenizer.h"
+#include "compiler/CRTTI.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
 #include "compiler/CodeGen.h"
 #include "compiler/CompilerTools.h"
+#include "compiler/PPCError.h"
 #include "compiler/objects.h"
 #include "compiler/scopes.h"
 #include "compiler/templates.h"
@@ -20,30 +29,6 @@
 Boolean (*name_obj_check)(HashNameNode *, Object *);
 Boolean disallowgreaterthan;
 
-// MOVE ME
-extern ENode *CIRTrans_TransformOpAss(ENode *);
-extern ENode *CTempl_MakeTemplDepExpr(ENode *, ENodeType, ENode *);
-extern Boolean CTemplTool_IsTemplateArgumentDependentType(Type *type);
-extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr);
-extern ENode *CSOM_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *expr);
-extern TemplArg *CTempl_ParseUncheckTemplArgs(void *a, Boolean flag);
-extern Boolean CObjC_IsCompatibleType(Type *a, Type *b);
-extern Type *CObjC_GetObjCType_id(Boolean flag);
-extern ENode *CExcept_ScanThrowExpression(void);
-extern void PPCError_Error(int code, ...);
-extern ENode *CObjC_ParseSelectorExpression(void);
-extern ENode *CObjC_ParseEncodeExpression(void);
-extern ENode *CObjC_ParseProtocolExpression(void);
-extern ENode *CObjC_ParseAtExpression(void);
-extern ENode *CObjC_ParseMessageExpression(void);
-extern ENode *CRTTI_Parse_const_cast(void);
-extern ENode *CRTTI_Parse_dynamic_cast(void);
-extern ENode *CRTTI_Parse_reinterpret_cast(void);
-extern ENode *CRTTI_Parse_static_cast(void);
-extern ENode *CRTTI_ParseTypeID(void);
-extern Boolean CObjC_IsType_id(Type *type);
-extern ENode *CObjC_CheckModernSendMessage(Type *type, ENode *expr);
-
 // forward declarations
 static ENode *makeaddnode(ENode *left, ENode *right);
 static ENode *makesubnode(ENode *left, ENode *right);
@@ -81,8 +66,7 @@ restart:
                         expr->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), cint64_zero);
                     break;
                 default:
-#line 105
-                    CError_FATAL();
+                    CError_FATAL(105);
             }
         }
     }
@@ -383,8 +367,7 @@ static ENode *integralpointerpromote(ENode *expr) {
                 } else if (stunsignedint.size == 4) {
                     type = TYPE(&stunsignedint);
                 } else {
-#line 480
-                    CError_FATAL();
+                    CError_FATAL(480);
                 }
             } else {
                 if (stsignedlong.size == 4) {
@@ -392,8 +375,7 @@ static ENode *integralpointerpromote(ENode *expr) {
                 } else if (stsignedint.size == 4) {
                     type = TYPE(&stsignedint);
                 } else {
-#line 486
-                    CError_FATAL();
+                    CError_FATAL(486);
                 }
             }
         }
@@ -865,8 +847,7 @@ static ENode *CExpr_MemberVarAccess(BClassList *path, ObjMemberVar *var, ENode *
     ENode *accessnode;
     BClassList *varpath;
 
-#line 1152
-    CError_ASSERT(path);
+    CError_ASSERT(1152, path);
 
     if (TYPE_CLASS(path->type)->sominfo)
         return CSOM_MemberVarAccess(path, var, expr);
@@ -952,8 +933,7 @@ ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr) {
                 CError_Error(0xDD);
                 return nullnode();
             default:
-#line 1268
-                CError_FATAL();
+                CError_FATAL(1268);
         }
     }
 
@@ -964,8 +944,7 @@ ENode *CExpr_MakeNameLookupResultExpr(CScopeParseResult *pr) {
         return expr;
     }
 
-#line 1278
-    CError_FATAL();
+    CError_FATAL(1278);
     return NULL;
 }
 
@@ -987,19 +966,16 @@ static Type *CExpr_NewPTMType(EMemberInfo *member, Object *obj) {
         ptm->ty1 = OBJ_MEMBER_VAR(member->list->object)->type;
     } else {
         if (!obj) {
-#line 1306
-            CError_ASSERT(member->list->object->otype == OT_OBJECT);
+            CError_ASSERT(1306, member->list->object->otype == OT_OBJECT);
             obj = OBJECT(member->list->object);
-#line 1308
-            CError_ASSERT(IS_TYPE_FUNC(obj->type));
+            CError_ASSERT(1308, IS_TYPE_FUNC(obj->type));
         }
 
         tmethod = galloc(sizeof(TypeMethod));
         memclrw(tmethod, sizeof(TypeMethod));
         *tmethod = *TYPE_METHOD(obj->type);
 
-#line 1312
-        CError_ASSERT(tmethod->args);
+        CError_ASSERT(1312, tmethod->args);
 
         tmethod->args = tmethod->args->next;
         CDecl_MakePTMFuncType(TYPE_FUNC(tmethod));
@@ -1139,8 +1115,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
                                 val++;
                             }
                             if (act->u.enumerator.objenumconst == oec) {
-#line 1521
-                                CError_ASSERT(expr);
+                                CError_ASSERT(1521, expr);
                                 expr = CInline_CopyExpression(expr, CopyMode0);
                                 if (val)
                                     expr = makediadicnode(expr, intconstnode(TYPE(&stsignedlong), val), EADD);
@@ -1168,8 +1143,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
                 }
                 break;
             default:
-#line 1552
-                CError_FATAL();
+                CError_FATAL(1552);
         }
 
         member = lalloc(sizeof(EMemberInfo));
@@ -1179,8 +1153,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
         member->pr_1D = pr->x1D;
         member->isambig = pr->isambig;
         if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) {
-#line 1564
-            CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST));
+            CError_ASSERT(1564, ENODE_IS(ta_expr, EOBJLIST));
             member->list = ta_expr->data.objlist.list;
             member->templargs = ta_expr->data.objlist.templargs;
         } else {
@@ -1197,8 +1170,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
 
     if (pr->nsol_14) {
         if ((tk = lex()) == '<' && (ta_expr = CExpr_ExplicitTemplateArgCheck(pr))) {
-#line 1591
-            CError_ASSERT(ENODE_IS(ta_expr, EOBJLIST));
+            CError_ASSERT(1591, ENODE_IS(ta_expr, EOBJLIST));
             for (list = ta_expr->data.objlist.list; list; list = list->next) {
                 if (list->object->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(OBJECT(list->object)->type)) {
                     member = lalloc(sizeof(EMemberInfo));
@@ -1290,8 +1262,7 @@ static ENode *CExpr_ParseNameResultExpr(CScopeParseResult *pr, ENode *expr, Bool
         return create_objectrefnode(obj);
     }
 
-#line 1711
-    CError_FATAL();
+    CError_FATAL(1711);
     return NULL;
 }
 
@@ -1462,8 +1433,7 @@ static SInt32 CExpr_AtomTypeID(IntegralType what) {
         case IT_23: return 38;
         case IT_24: return 39;
         default:
-#line 1976
-            CError_FATAL();
+            CError_FATAL(1976);
             return 0;
     }
 }
@@ -1734,8 +1704,7 @@ static ENode *CExpr_NewPTMFCall(void) {
         CError_Error(115);
         return nullnode();
     } else {
-#line 2465
-        CError_FATAL();
+        CError_FATAL(2465);
         return nullnode();
     }
 }
@@ -1770,8 +1739,7 @@ static ENode *call_ptmf(ENode *expr) {
     list2->node = expr->data.mfpointer.mfpointer->data.monadic;
 
     if (!copts.old_argmatch) {
-#line 2568
-        CError_ASSERT(IS_TYPE_POINTER_ONLY(list2->node->rtype));
+        CError_ASSERT(2568, IS_TYPE_POINTER_ONLY(list2->node->rtype));
         list2->node->rtype = TYPE(&void_ptr);
     }
 
@@ -1938,9 +1906,8 @@ loop:
                     goto loop;
                 }
 
-#line 2753
-                CError_ASSERT((expr = conv.left));
-                CError_ASSERT((subexpr = conv.right));
+                CError_ASSERT(2753, expr = conv.left);
+                CError_ASSERT(2754, subexpr = conv.right);
             }
 
             if (IS_TYPE_POINTER(expr->rtype)) {
@@ -1964,8 +1931,7 @@ loop:
             funcexpr = CExpr_PointerGeneration(expr);
             if (copts.cplusplus) {
                 if (CExpr_CheckOperator('(', funcexpr, NULL, &conv)) {
-#line 2775
-                    CError_ASSERT((expr = conv.x0));
+                    CError_ASSERT(2775, expr = conv.x0);
                     goto loop;
                 }
                 if (ENODE_IS(funcexpr, EMFPOINTER)) {
@@ -1996,8 +1962,7 @@ loop:
             expr = pointer_generation(expr);
             if (copts.cplusplus) {
                 while (IS_TYPE_CLASS(expr->rtype) && CExpr_CheckOperator(TK_ARROW, expr, NULL, &conv)) {
-#line 2810
-                    CError_ASSERT((subexpr = conv.x0));
+                    CError_ASSERT(2810, subexpr = conv.x0);
                     expr = pointer_generation(subexpr);
                 }
             }
@@ -2020,7 +1985,7 @@ loop:
             expr = pointer_generation(expr);
             if (IS_TYPE_CLASS(expr->rtype)) {
                 CDecl_CompleteType(expr->rtype);
-                if (TYPE_CLASS(expr->rtype)->objcinfo && copts.cplusplus && (subexpr = CObjC_CheckModernSendMessage(expr->rtype, expr)))
+                if (TYPE_CLASS(expr->rtype)->objcinfo && copts.cplusplus && (subexpr = CObjC_CheckModernSendMessage(TYPE_CLASS(expr->rtype), expr)))
                     return subexpr;
 
                 if (!(TYPE_CLASS(expr->rtype)->flags & CLASS_FLAGS_2))
@@ -2100,8 +2065,7 @@ loop:
                     tk = lex();
                     goto loop;
                 }
-#line 2952
-                CError_ASSERT((tmp = conv.left));
+                CError_ASSERT(2952, tmp = conv.left);
             }
             tmp = CExpr_LValue(tmp, 1, 1);
             if (tmp->rtype == TYPE(&stbool)) {
@@ -2121,8 +2085,7 @@ loop:
                     tk = lex();
                     goto loop;
                 }
-#line 2976
-                CError_ASSERT((tmp = conv.left));
+                CError_ASSERT(2976, tmp = conv.left);
             }
             tmp = CExpr_LValue(tmp, 1, 1);
             checkadditive(tmp);
@@ -2320,8 +2283,7 @@ static ENode *CExpr_MakeStaticMemberList(NameSpaceObjectList *list) {
 static ENode *CExpr_MakePTDM(ENode *expr) {
     ENode *result;
 
-#line 3414
-    CError_ASSERT(ENODE_IS(expr, EMEMBER) && expr->data.emember->list->object->otype == OT_MEMBERVAR);
+    CError_ASSERT(3414, ENODE_IS(expr, EMEMBER) && expr->data.emember->list->object->otype == OT_MEMBERVAR);
 
     result = nullnode();
     result->rtype = CExpr_NewPTMType(expr->data.emember, NULL);
@@ -2338,8 +2300,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
     OLinkList *olist;
     SInt32 data[3];
 
-#line 3442
-    CError_ASSERT(ENODE_IS(expr, EMEMBER));
+    CError_ASSERT(3442, ENODE_IS(expr, EMEMBER));
 
     if (expr->data.emember->expr && !copts.cpp_extensions)
         CError_Error(141);
@@ -2378,8 +2339,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
     while (obj->datatype == DALIAS)
         obj = obj->u.alias.object;
 
-#line 3503
-    CError_ASSERT(obj->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(obj->type));
+    CError_ASSERT(3503, obj->otype == OT_OBJECT && IS_TYPE_NONSTATIC_METHOD(obj->type));
 
     if (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)
         CError_Error(190);
@@ -2414,8 +2374,7 @@ ENode *getpointertomemberfunc(ENode *expr, Type *type, Boolean flag) {
 }
 
 static ENode *getpointertomember(ENode *expr) {
-#line 3554
-    CError_ASSERT(ENODE_IS(expr, EMEMBER));
+    CError_ASSERT(3554, ENODE_IS(expr, EMEMBER));
 
     if (expr->data.emember->expr)
         CError_Error(141);
@@ -2442,8 +2401,7 @@ ENode *CExpr_New_ELOGNOT_Node(ENode *input) {
     if (copts.cplusplus && CExpr_CheckOperator('!', expr, NULL, &conv)) {
         if ((input = conv.x0))
             return input;
-#line 3593
-        CError_ASSERT((expr = conv.left));
+        CError_ASSERT(3593, expr = conv.left);
     }
 
     switch (expr->rtype->type) {
@@ -2489,8 +2447,7 @@ ENode *CExpr_New_EMONMIN_Node(ENode *input) {
     if (copts.cplusplus && CExpr_CheckOperator('-', expr, NULL, &conv)) {
         if ((input = conv.x0))
             return input;
-#line 3652
-        CError_ASSERT((expr = conv.left));
+        CError_ASSERT(3652, expr = conv.left);
     }
 
     switch (expr->rtype->type) {
@@ -2525,8 +2482,7 @@ ENode *CExpr_New_EBINNOT_Node(ENode *input) {
     if (copts.cplusplus && CExpr_CheckOperator('~', expr, NULL, &conv)) {
         if ((input = conv.x0))
             return input;
-#line 3702
-        CError_ASSERT((expr = conv.left));
+        CError_ASSERT(3702, expr = conv.left);
     }
 
     expr = integralpromote(expr);
@@ -2566,8 +2522,7 @@ ENode *unary_expression(void) {
                 if (CExpr_CheckOperator(TK_INCREMENT, expr, NULL, &conv)) {
                     if (conv.x0)
                         return conv.x0;
-#line 3748
-                    CError_ASSERT((expr = conv.left));
+                    CError_ASSERT(3748, expr = conv.left);
                 }
             } else {
                 expr = pointer_generation(unary_expression());
@@ -2589,8 +2544,7 @@ ENode *unary_expression(void) {
                 if (CExpr_CheckOperator(TK_DECREMENT, expr, NULL, &conv)) {
                     if (conv.x0)
                         return conv.x0;
-#line 3776
-                    CError_ASSERT((expr = conv.left));
+                    CError_ASSERT(3776, expr = conv.left);
                 }
             } else {
                 expr = pointer_generation(unary_expression());
@@ -2614,8 +2568,7 @@ ENode *unary_expression(void) {
                 }
 
                 if (CExpr_CheckOperator('&', expr, NULL, &conv)) {
-#line 3809
-                    CError_ASSERT(conv.x0);
+                    CError_ASSERT(3809, conv.x0);
                     return conv.x0;
                 }
             } else {
@@ -2642,8 +2595,7 @@ ENode *unary_expression(void) {
             if (copts.cplusplus && CExpr_CheckOperator('*', expr, NULL, &conv)) {
                 if (conv.x0)
                     return conv.x0;
-#line 3840
-                CError_ASSERT((expr = conv.left));
+                CError_ASSERT(3840, expr = conv.left);
             }
 
             if (!IS_TYPE_POINTER(expr->rtype)) {
@@ -2661,8 +2613,7 @@ ENode *unary_expression(void) {
             if (copts.cplusplus && CExpr_CheckOperator('+', expr, NULL, &conv)) {
                 if (conv.x0)
                     return conv.x0;
-#line 3852
-                CError_ASSERT((expr = conv.left));
+                CError_ASSERT(3852, expr = conv.left);
             }
 
             switch (expr->rtype->type) {
@@ -2761,10 +2712,8 @@ ENode *PointerToMemberCast(ENode *expr, TypeMemberPointer *tm1, TypeMemberPointe
     CInt64 pathoffset64;
     ENode *tmp;
 
-#line 3984
-    CError_ASSERT(IS_TYPE_CLASS(tm1->ty2));
-#line 3985
-    CError_ASSERT(IS_TYPE_CLASS(tm2->ty2));
+    CError_ASSERT(3984, IS_TYPE_CLASS(tm1->ty2));
+    CError_ASSERT(3985, IS_TYPE_CLASS(tm2->ty2));
 
     if (tm1->ty2 == tm2->ty2) {
         expr->rtype = TYPE(tm2);
@@ -3113,8 +3062,7 @@ restart:
             right = pointer_generation(cast_expression());
 
             if (CExpr_CheckOperator(TK_ARROW_STAR, left, right, &conv)) {
-#line 4457
-                CError_ASSERT((left = conv.x0));
+                CError_ASSERT(4457, left = conv.x0);
                 goto restart;
             }
 
@@ -3192,8 +3140,7 @@ restart:
                 left = checkreference(left);
                 goto restart;
             } else {
-#line 4535
-                CError_ASSERT(ENODE_IS(right, EINDIRECT));
+                CError_ASSERT(4535, ENODE_IS(right, EINDIRECT));
                 tmp = lalloc(sizeof(ENode));
                 tmp->type = EMFPOINTER;
                 tmp->cost = 4;
@@ -3219,9 +3166,8 @@ ENode *CExpr_New_EMUL_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('*', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4566
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4566, left = conv.left);
+        CError_ASSERT(4567, right = conv.right);
     }
 
     return makemultnode(left, right);
@@ -3238,9 +3184,8 @@ ENode *CExpr_New_EDIV_Node(ENode *left, ENode *right, Boolean no_warning) {
     if (copts.cplusplus && CExpr_CheckOperator('/', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4592
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4592, left = conv.left);
+        CError_ASSERT(4593, right = conv.right);
     }
 
     return makedivnode(left, right, no_warning);
@@ -3257,9 +3202,8 @@ ENode *CExpr_New_EMODULO_Node(ENode *left, ENode *right, Boolean no_warning) {
     if (copts.cplusplus && CExpr_CheckOperator('%', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4618
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4618, left = conv.left);
+        CError_ASSERT(4619, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3300,9 +3244,8 @@ ENode *CExpr_New_EADD_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('+', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4665
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4665, left = conv.left);
+        CError_ASSERT(4666, right = conv.right);
     }
 
     return makeaddnode(left, right);
@@ -3319,9 +3262,8 @@ ENode *CExpr_New_ESUB_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('-', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4690
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4690, left = conv.left);
+        CError_ASSERT(4691, right = conv.right);
     }
 
     return makesubnode(left, right);
@@ -3338,9 +3280,8 @@ ENode *CExpr_New_ESHL_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_SHL, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4715
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4715, left = conv.left);
+        CError_ASSERT(4716, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3369,9 +3310,8 @@ ENode *CExpr_New_ESHR_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_SHR, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4752
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4752, left = conv.left);
+        CError_ASSERT(4753, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3421,14 +3361,12 @@ static ENode *pointercompare(ENodeType nt, ENode *left, ENode *right) {
         if (IS_TYPE_INT(ltype)) {
             if (!(ENODE_IS(left, EINTCONST) && CInt64_IsZero(&left->data.intval)))
                 CError_Error(144);
-#line 4847
-            CError_ASSERT(IS_TYPE_POINTER_ONLY(rtype));
+            CError_ASSERT(4847, IS_TYPE_POINTER_ONLY(rtype));
             left->rtype = TYPE(&stunsignedlong);
         } else if (IS_TYPE_INT(rtype)) {
             if (!(ENODE_IS(right, EINTCONST) && CInt64_IsZero(&right->data.intval)))
                 CError_Error(144);
-#line 4855
-            CError_ASSERT(IS_TYPE_POINTER_ONLY(ltype));
+            CError_ASSERT(4855, IS_TYPE_POINTER_ONLY(ltype));
             right->rtype = TYPE(&stunsignedlong);
         } else if (!is_typeequal(ltype, rtype)) {
             CError_Error(245, left->rtype, ENODE_QUALS(left), right->rtype, ENODE_QUALS(right));
@@ -3473,9 +3411,8 @@ ENode *CExpr_New_ELESS_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('<', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4929
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4929, left = conv.left);
+        CError_ASSERT(4930, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3507,9 +3444,8 @@ ENode *CExpr_New_ELESSEQU_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_LESS_EQUAL, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 4976
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(4976, left = conv.left);
+        CError_ASSERT(4977, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3541,9 +3477,8 @@ ENode *CExpr_New_EGREATER_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('>', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5023
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5023, left = conv.left);
+        CError_ASSERT(5024, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3575,9 +3510,8 @@ ENode *CExpr_New_EGREATEREQU_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_GREATER_EQUAL, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5070
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5070, left = conv.left);
+        CError_ASSERT(5071, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3664,9 +3598,8 @@ ENode *CExpr_New_EEQU_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_EQ, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5201
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5201, left = conv.left);
+        CError_ASSERT(5202, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3702,9 +3635,8 @@ ENode *CExpr_New_ENOTEQU_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_NE, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5261
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5261, left = conv.left);
+        CError_ASSERT(5262, right = conv.right);
     }
 
     if (IS_TYPE_POINTER(left->rtype) || IS_TYPE_POINTER(right->rtype))
@@ -3739,9 +3671,8 @@ ENode *CExpr_New_EAND_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('&', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5321
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5321, left = conv.left);
+        CError_ASSERT(5322, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3774,9 +3705,8 @@ ENode *CExpr_New_EXOR_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('^', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5360
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5360, left = conv.left);
+        CError_ASSERT(5361, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3809,9 +3739,8 @@ ENode *CExpr_New_EOR_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator('|', left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5399
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5399, left = conv.left);
+        CError_ASSERT(5400, right = conv.right);
     }
 
     left = integralpromote(left);
@@ -3844,9 +3773,8 @@ ENode *CExpr_New_ELAND_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_AND, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5438
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5438, left = conv.left);
+        CError_ASSERT(5439, right = conv.right);
     }
 
     switch (left->rtype->type) {
@@ -3930,9 +3858,8 @@ ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right) {
     if (copts.cplusplus && CExpr_CheckOperator(TK_LOGICAL_OR, left, right, &conv)) {
         if (conv.x0)
             return conv.x0;
-#line 5543
-        CError_ASSERT((left = conv.left));
-        CError_ASSERT((right = conv.right));
+        CError_ASSERT(5543, left = conv.left);
+        CError_ASSERT(5544, right = conv.right);
     }
 
     switch (left->rtype->type) {
@@ -4006,8 +3933,7 @@ ENode *CExpr_New_ELOR_Node(ENode *left, ENode *right) {
 ENode *CExpr_NewDyadicNode(ENode *left, ENodeType nt, ENode *right) {
     switch (nt) {
         default:
-#line 5642
-            CError_FATAL();
+            CError_FATAL(5642);
         case EADD: return CExpr_New_EADD_Node(left, right);
         case ESUB: return CExpr_New_ESUB_Node(left, right);
         case EMUL: return CExpr_New_EMUL_Node(left, right);
@@ -4266,8 +4192,7 @@ ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2) {
     if ((IS_TYPE_CLASS(expr1->rtype) || IS_TYPE_CLASS(expr2->rtype)) && !is_typesame(expr1->rtype, expr2->rtype)) {
         if (!copts.old_argmatch) {
             if (CExpr_CondOperatorMatch(expr1, expr2, &conv)) {
-#line 6246
-                CError_ASSERT(!conv.x0);
+                CError_ASSERT(6246, !conv.x0);
                 expr1 = conv.left;
                 expr2 = conv.right;
             } else if (CExpr_CanImplicitlyConvert(expr1, expr2->rtype, ENODE_QUALS(expr2))) {
@@ -4289,8 +4214,7 @@ ENode *CExpr_New_ECOND_Node(ENode *cond, ENode *expr1, ENode *expr2) {
             args->next->next = NULL;
 
             if (CExpr_CheckOperatorConversion(':', expr1, expr2, args, &conv)) {
-#line 6274
-                CError_ASSERT(!conv.x0);
+                CError_ASSERT(6274, !conv.x0);
                 expr1 = conv.left;
                 expr2 = conv.right;
             }
@@ -4479,8 +4403,7 @@ static ENode *makeassignmentnode(ENode *left, ENodeType nt, short token) {
             if (!conv.x0) {
                 if (nt == EASS)
                     goto continue_anyway;
-#line 6531
-                CError_FATAL();
+                CError_FATAL(6531);
             }
             return conv.x0;
         }
@@ -4553,11 +4476,9 @@ continue_anyway:
             case 1:
                 if ((args = args->next))
                     break;
-#line 6625
-                CError_FATAL();
+                CError_FATAL(6625);
             default:
-#line 6626
-                CError_FATAL();
+                CError_FATAL(6626);
         }
         if (ENODE_IS(args->node, ETEMP)) {
             if (!(IS_TYPE_CLASS(left->rtype) && CClass_Destructor(TYPE_CLASS(left->rtype)))) {
@@ -4583,8 +4504,7 @@ static ENode *makepassignmentnode(ENode *left, ENodeType nt, short token) {
         tk = lex();
         right = pointer_generation(assignment_expression());
         if (CExpr_CheckOperator(token, left, right, &conv)) {
-#line 6669
-            CError_ASSERT(conv.x0);
+            CError_ASSERT(6669, conv.x0);
             return conv.x0;
         }
         left = CExpr_LValue(left, 1, 1);
@@ -4652,8 +4572,7 @@ static ENode *makemulassignmentnode(ENode *left, ENodeType nt, short token) {
         tk = lex();
         right = pointer_generation(assignment_expression());
         if (CExpr_CheckOperator(token, left, right, &conv)) {
-#line 6753
-            CError_ASSERT(conv.x0);
+            CError_ASSERT(6753, conv.x0);
             return conv.x0;
         }
         if (!IS_TYPE_INT(left->rtype) && !(IS_TYPE_FLOAT(left->rtype) && nt != EMODASS)) {
@@ -4865,8 +4784,7 @@ static Boolean CExpr_HasSideEffect(ENode *expr) {
         case EINSTRUCTION:
             return 1;
         default:
-#line 7056
-            CError_FATAL();
+            CError_FATAL(7056);
             return 0;
     }
 }
@@ -4911,11 +4829,9 @@ void CExpr_CheckUnusedExpression(ENode *expr) {
                         case 1:
                             if ((arg = arg->next))
                                 break;
-#line 7110
-                            CError_FATAL();
+                            CError_FATAL(7110);
                         default:
-#line 7111
-                            CError_FATAL();
+                            CError_FATAL(7111);
                     }
 
                     if (!ENODE_IS(arg->node, ETEMP))
@@ -4938,8 +4854,7 @@ ENode *s_expression(void) {
         right = pointer_generation(assignment_expression());
 
         if (copts.cplusplus && CExpr_CheckOperator(',', left, right, &conv)) {
-#line 7143
-            CError_ASSERT((left = conv.x0));
+            CError_ASSERT(7143, left = conv.x0);
         } else {
             CExpr_CheckUnusedExpression(left);
             left = makecommaexpression(left, right);
@@ -4986,8 +4901,7 @@ ENode *CExpr_IntegralConstOrDepExpr(void) {
                 expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
                 return expr;
             default:
-#line 7209
-                CError_FATAL();
+                CError_FATAL(7209);
         }
     }
 
diff --git a/compiler_and_linker/unsorted/CExpr2.c b/compiler_and_linker/unsorted/CExpr2.c
index 67f4fb7..e2284d7 100644
--- a/compiler_and_linker/unsorted/CExpr2.c
+++ b/compiler_and_linker/unsorted/CExpr2.c
@@ -9,9 +9,14 @@
 #include "compiler/CInline.h"
 #include "compiler/CMachine.h"
 #include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CObjCModern.h"
 #include "compiler/CParser.h"
 #include "compiler/CPrepTokenizer.h"
 #include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CTemplateTools.h"
 #include "compiler/CodeGen.h"
 #include "compiler/CompilerTools.h"
 #include "compiler/enode.h"
@@ -28,21 +33,6 @@
 #define va_arg(ap, type) (*(((type *) (ap = (char *)((((unsigned long)ap + __builtin_align(type) - 1) & ~(__builtin_align(type) - 1) ) + sizeof(type)))) - 1))
 #endif
 
-// TODO MOVE ME
-extern ENode *CObjC_New(TypeClass *tclass);
-extern Boolean CObjC_IsType_id(Type *type);
-extern ENode *CObjC_Delete(TypeClass *tclass, ENode *expr);
-extern ENode *CSOM_New(TypeClass *tclass);
-extern ENode *CSOM_Delete(TypeClass *tclass, ENode *expr);
-extern ENode *CSOM_EnvCheck(ENode *, ENodeList *);
-extern ENode *CSOM_MethodAccess(BClassList *, Object *, Boolean);
-extern Boolean CTemplTool_IsTemplateArgumentDependentExpression(ENode *expr);
-extern ENode *CTemplTool_DeduceDefaultArg(Object *func, ENode *expr);
-extern Boolean CTempl_CanDeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs);
-extern void CTempl_FuncMatch(NameSpaceObjectList *nsol, TemplArg *templargs, ENodeList *argexprs, Match13 *match, ENode *expr);
-extern TemplFuncInstance *CTempl_DeduceFunc(Object *func, TypeFunc *tfunc, TemplArg *templargs, Object *anotherobj, Boolean flag);
-extern Boolean CObjC_IsCompatibleType(Type *a, Type *b);
-
 ENode *assign_node;
 Boolean temp_reference_init;
 static SInt32 assign_value; // type?
@@ -172,8 +162,7 @@ restart:
                 CExpr_RecSearchExprTree(expr->data.itc.result);
             return;
         default:
-#line 128
-            CError_FATAL();
+            CError_FATAL(128);
     }
 }
 
@@ -296,8 +285,7 @@ static ENode *CExpr_RecSearchExprTreeReplace(ENode *expr) {
             expr->data.cond.expr2 = CExpr_RecSearchExprTreeReplace(expr->data.cond.expr2);
             return expr;
         default:
-#line 220
-            CError_FATAL();
+            CError_FATAL(220);
             return NULL;
     }
 }
@@ -557,13 +545,13 @@ ENode *CExpr_NewETEMPNode(Type *type, Boolean assign_id) {
 static ENode *CExpr_DerefETEMPCopy(ENode *expr) {
     ENode *copy;
 
-#line 636
-    CError_ASSERT(expr->rtype->type == TYPEPOINTER);
+    CError_ASSERT(636, IS_TYPE_POINTER_ONLY(expr->rtype));
 
     copy = lalloc(sizeof(ENode));
     *copy = *expr;
     copy = makemonadicnode(copy, EINDIRECT);
     copy->rtype = TYPE_POINTER(copy->rtype)->target;
+    return copy;
 }
 
 ENode *CExpr_GetETEMPCopy(ENode *expr) {
@@ -682,8 +670,7 @@ void CExpr_ArithmeticConversion(ENode **left, ENode **right) {
             if ((*left)->rtype == (Type *) &stsignedlong) {
                 *left = promote(*left, (Type *) &stunsignedlong);
             } else {
-#line 838
-                CError_ASSERT((*left)->rtype == (Type *) &stsignedlonglong);
+                CError_ASSERT(838, (*left)->rtype == (Type *) &stsignedlonglong);
                 *left = promote(*left, (Type *) &stunsignedlonglong);
             }
         }
@@ -742,14 +729,13 @@ static ENode *CExpr_GetEA(ENode *expr) {
 }
 
 ENode *CExpr_TempModifyExpr(ENode *expr) {
-    // register issues
     Type *type;
-    ENode *tempnode;
-    ENode *eanode;
-    ENode *assnode2;
     ENode *left;
     ENode *right;
-    ENode *work;
+    ENode *eanode;
+    ENode *tempnode;
+    ENode *indnode;
+    ENode *truenode;
 
     type = expr->rtype;
     tempnode = CExpr_NewETEMPNode(type, 1);
@@ -759,23 +745,24 @@ ENode *CExpr_TempModifyExpr(ENode *expr) {
         return expr;
     }
 
+    // tempnode = expr
     left = makemonadicnode(tempnode, EINDIRECT);
     left->rtype = type;
-    work = makediadicnode(left, expr, EASS);
+    left = makediadicnode(left, expr, EASS);
 
-    left = makemonadicnode(eanode, EINDIRECT);
-    left->rtype = type;
-    right = nullnode();
-    right->rtype = (Type *) &stbool;
-    CInt64_SetLong(&right->data.intval, 1);
-    assnode2 = makediadicnode(left, right, EASS);
+    // eanode = true
+    indnode = makemonadicnode(eanode, EINDIRECT);
+    indnode->rtype = type;
+    truenode = nullnode();
+    truenode->rtype = (Type *) &stbool;
+    CInt64_SetLong(&truenode->data.intval, 1);
+    right = makediadicnode(indnode, truenode, EASS);
 
-    work = makediadicnode(work, assnode2, ECOMMA);
-    right = makemonadicnode(tempnode, EINDIRECT);
-    right->rtype = type;
-    work = makediadicnode(work, right, ECOMMA);
+    expr = makediadicnode(left, right, ECOMMA);
 
-    return work;
+    indnode = makemonadicnode(tempnode, EINDIRECT);
+    indnode->rtype = type;
+    return makediadicnode(expr, indnode, ECOMMA);
 }
 
 Boolean CExpr_IsLValue(ENode *expr) {
@@ -924,7 +911,7 @@ loop:
 ENode *CExpr_MakeObjRefNode(Object *obj, Boolean flag) {
     ENode *expr;
 
-    if (obj->sclass == OBJECT_SCLASS_104) {
+    if (obj->sclass == TK_TYPEDEF) {
         CError_Error(141);
         return intconstnode((Type *) &void_ptr, 0);
     }
@@ -978,16 +965,20 @@ ENode *CExpr_IsTempConstruction(ENode *expr, Type *type, ENode **resultexpr) {
     ENode *funccall;
     ENode *funcref;
 
-    if (!ENODE_IS(expr, EINDIRECT) || expr->rtype != type || !ENODE_IS((funccall = expr->data.monadic), EFUNCCALL) || !(args = funccall->data.funccall.args))
+    if (
+        !ENODE_IS(expr, EINDIRECT) ||
+        expr->rtype != type ||
+        !ENODE_IS((funccall = expr->data.monadic), EFUNCCALL) ||
+        !(args = funccall->data.funccall.args)
+        )
         return NULL;
 
     if (!ENODE_IS((funcref = funccall->data.funccall.funcref), EOBJREF) || !CClass_IsConstructor(funcref->data.objref)) {
         if (expr->data.monadic->data.funccall.functype->functype != type)
             return NULL;
-        if (CABI_GetStructResultArgumentIndex() == 1) {
+        if (CABI_GetStructResultArgumentIndex(expr->data.monadic->data.funccall.functype) == 1) {
             args = args->next;
-#line 1277
-            CError_ASSERT(args);
+            CError_ASSERT(1277, args);
         }
     }
 
@@ -1040,8 +1031,7 @@ ENode *funccallexpr(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, ENode *
     ENodeList *list;
 
     tfunc = TYPE_FUNC(func->type);
-#line 1411
-    CError_ASSERT(IS_TYPE_FUNC(tfunc));
+    CError_ASSERT(1411, IS_TYPE_FUNC(tfunc));
 
     expr = lalloc(sizeof(ENode));
     expr->type = EFUNCCALL;
@@ -1084,8 +1074,7 @@ ENode *CExpr_FuncCallSix(Object *func, ENode *arg1, ENode *arg2, ENode *arg3, EN
     ENodeList *list;
 
     tfunc = TYPE_FUNC(func->type);
-#line 1460
-    CError_ASSERT(IS_TYPE_FUNC(tfunc));
+    CError_ASSERT(1460, IS_TYPE_FUNC(tfunc));
 
     expr = lalloc(sizeof(ENode));
     expr->type = EFUNCCALL;
@@ -1134,8 +1123,7 @@ static void CExpr_CalcStdAssign(short checkresult, Match5 *match, Type *t1, UInt
             match->x6 += assign_value;
             break;
         default:
-#line 1504
-            CError_FATAL();
+            CError_FATAL(1504);
     }
 
     if (flag || (IS_TYPE_POINTER_ONLY(t2) && (IS_TYPE_POINTER_ONLY(t1) || IS_TYPEPOINTER_REFERENCE(TYPE_POINTER(t2))) != 0)) {
@@ -1197,8 +1185,7 @@ Boolean CExpr_MatchAssign(Type *type, UInt32 qual, ENode *expr, Match13 *match)
             match->match5.x8 += user_std_match.x8;
             break;
         default:
-#line 1585
-            CError_FATAL();
+            CError_FATAL(1585);
     }
 
     if (IS_TYPE_POINTER_ONLY(type))
@@ -1234,7 +1221,7 @@ static short CExpr2_MemberPointerConversion(Type *type, ENode *expr, Boolean fla
     newnode = lalloc(sizeof(ENode));
     *newnode = *expr;
     if (!IS_TYPE_MEMBERPOINTER(newnode->rtype)) {
-        newnode = CExpr_MemberPointerConversion(newnode, type, flag1);
+        newnode = CExpr_MemberPointerConversion(newnode, TYPE_MEMBER_POINTER(type), flag1);
         if (iscpp_typeequal(newnode->rtype, type)) {
             if (flag1)
                 assign_node = newnode;
@@ -1243,10 +1230,8 @@ static short CExpr2_MemberPointerConversion(Type *type, ENode *expr, Boolean fla
     }
 
     if (IS_TYPE_MEMBERPOINTER(newnode->rtype)) {
-#line 1656
-        CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2));
-#line 1657
-        CError_ASSERT(IS_TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2));
+        CError_ASSERT(1656, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2));
+        CError_ASSERT(1657, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2));
 
         if (CClass_IsBaseClass(TYPE_CLASS(TYPE_MEMBER_POINTER(type)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(newnode->rtype)->ty2), &depth, 0, 0)) {
             assign_value = 1000 - depth;
@@ -1270,8 +1255,7 @@ ENode *CExpr_ClassPointerCast(BClassList *cls, ENode *origexpr, Boolean nullchec
     expr = origexpr;
     tclass = TYPE_CLASS(cls->type);
     do_nullcheck = 0;
-#line 1691
-    CError_ASSERT(cls);
+    CError_ASSERT(1691, cls);
 
     if (!IS_TYPE_POINTER_ONLY(origexpr->rtype)) {
         CError_Error(CErrorStr141);
@@ -1346,10 +1330,8 @@ ENode *CExpr_GetClassAccessNode(BClassList *a, BClassList *b, ENode *expr, Objec
         expr->rtype = TYPE(cscope_currentclass);
     }
 
-#line 1786
-    CError_ASSERT(a);
-#line 1787
-    CError_ASSERT(IS_TYPE_CLASS(expr->rtype));
+    CError_ASSERT(1786, a);
+    CError_ASSERT(1787, IS_TYPE_CLASS(expr->rtype));
 
     tclass = TYPE_CLASS(expr->rtype);
     a = CScope_GetClassAccessPath(a, tclass);
@@ -1411,8 +1393,7 @@ static short std_assign_check_overload(NameSpaceObjectList *list, TemplArg *temp
         if (IS_TYPE_FUNC(obj->type) && (TYPE_FUNC(obj->type)->flags & FUNC_FLAGS_100000)) {
             if (!found_non_template_func && CTempl_CanDeduceFunc(obj, TYPE_FUNC(type), templargs)) {
                 instance = CTempl_DeduceFunc(obj, TYPE_FUNC(type), templargs, NULL, 0);
-#line 1861
-                CError_ASSERT(instance);
+                CError_ASSERT(1861, instance);
                 if (is_typesame(instance->object->type, type)) {
                     if (used_obj && used_obj != instance->object)
                         is_ambig = 1;
@@ -1458,7 +1439,7 @@ static short std_assign_check_overload(NameSpaceObjectList *list, TemplArg *temp
     }
 }
 
-ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag) {
+ENode *CExpr_ConvertToBool(ENode *expr, Boolean isExplicit) {
     if (IS_TYPE_MEMBERPOINTER(expr->rtype))
         expr = CExpr_ConvertToCondition(expr);
 
@@ -1485,7 +1466,7 @@ ENode *CExpr_ConvertToBool(ENode *expr, Boolean flag) {
             break;
         default:
             CError_Error(
-                    flag ? CErrorStr247 : CErrorStr209,
+                    isExplicit ? CErrorStr247 : CErrorStr209,
                     expr->rtype,
                     expr->flags & ENODE_FLAG_QUALS,
                     &stbool,
@@ -1841,8 +1822,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
     UInt16 chk;
     Boolean is_const, is_volatile;
 
-#line 2378
-    CError_ASSERT(copts.old_argmatch);
+    CError_ASSERT(2378, copts.old_argmatch);
 
     memclrw(&stdmatch, sizeof(Match5));
     r24 = 0;
@@ -1872,8 +1852,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
             }
             if ((result = std_assign_check(r14, type, 0, flag3))) {
                 CExpr_CalcStdAssign(result, &match_98, r17->functype, r17->qual, type, qual, 1);
-#line 2419
-                CError_ASSERT(r17->args && IS_TYPE_POINTER_ONLY(r17->args->type));
+                CError_ASSERT(2419, r17->args && IS_TYPE_POINTER_ONLY(r17->args->type));
                 chk = expr->flags;
                 if (!(is_const = (r17->args->qual & Q_CONST)) && (chk & Q_CONST) != 0)
                     continue;
@@ -1976,8 +1955,7 @@ short user_assign_check(ENode *expr, Type *type, UInt32 qual, Boolean flag1, Boo
         if (flag1) {
             if (r24) {
                 r13 = TYPE_METHOD(r26->type);
-#line 2537
-                CError_ASSERT(r13->flags & FUNC_FLAGS_METHOD);
+                CError_ASSERT(2537, r13->flags & FUNC_FLAGS_METHOD);
                 r15b = create_objectrefnode(r26);
                 r26->flags |= OBJECT_FLAGS_UNUSED;
                 r14d = lalloc(sizeof(ENodeList));
@@ -2092,8 +2070,7 @@ void CExpr_CheckArithmConversion(ENode *expr, Type *type) {
     if (IS_TYPE_INT(expr->rtype)) {
         if (IS_TYPE_FLOAT(type))
             return;
-#line 2772
-        CError_ASSERT(IS_TYPE_INT(type));
+        CError_ASSERT(2772, IS_TYPE_INT(type));
 
         if (type->size > expr->rtype->size)
             return;
@@ -2152,8 +2129,7 @@ ENode *get_address_of_temp_copy(ENode *expr, Boolean flag) {
                         innertype = TYPE(&stunsignedlong);
                         break;
                     default:
-#line 2857
-                        CError_FATAL();
+                        CError_FATAL(2857);
                 }
                 CMach_InitIntMem(innertype, expr->data.intval, buf);
             } else {
@@ -2440,8 +2416,7 @@ ENode *CExpr_GetDefaultArgument(ENode *funcexpr, FuncArg *arg) {
     ENode *tmp;
 
     if (CTemplTool_IsTemplateArgumentDependentExpression(arg->dexpr)) {
-#line 3264
-        CError_ASSERT(ENODE_IS(funcexpr, EOBJREF));
+        CError_ASSERT(3264, ENODE_IS(funcexpr, EOBJREF));
         tmp = CTemplTool_DeduceDefaultArg(
                 funcexpr->data.objref,
                 CInline_CopyExpression(arg->dexpr, CopyMode0)
@@ -2650,8 +2625,7 @@ ENode *CExpr_GenericFuncCall(BClassList *path, ENode *funcexpr, Boolean flag1, O
         scan_arg = tfunc->args;
         scan_expr = nodes;
         if (tfunc->flags & FUNC_FLAGS_METHOD) {
-#line 3599
-            CError_ASSERT(TYPE_METHOD(tfunc)->theclass->sominfo == NULL);
+            CError_ASSERT(3599, TYPE_METHOD(tfunc)->theclass->sominfo == NULL);
         }
     }
 
@@ -2883,8 +2857,7 @@ static Boolean accept_conversion_type(Type *type, short mode) {
         case 3:
             return IS_TYPE_POINTER_ONLY(type);
         default:
-#line 3912
-            CError_FATAL();
+            CError_FATAL(3912);
             return 0;
     }
 }
@@ -3077,8 +3050,7 @@ static Boolean is_legal_type_combination(Type *left, Type *right, short mode) {
             diadic_arg2.type = right;
             return 1;
         default:
-#line 4132
-            CError_FATAL();
+            CError_FATAL(4132);
             return 0;
     }
 }
@@ -3272,8 +3244,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
                     tk = lex();
                     return 1;
                 } else {
-#line 4371
-                    CError_FATAL();
+                    CError_FATAL(4371);
                 }
             }
             return 0;
@@ -3320,8 +3291,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
                 tk = lex();
                 return 1;
             } else {
-#line 4439
-                CError_FATAL();
+                CError_FATAL(4439);
             }
         }
         return 0;
@@ -3344,8 +3314,7 @@ Boolean CExpr_CheckOperator(short token, ENode *left, ENode *right, Conversion *
             mylist_B0.object = pr2.obj_10;
             pr2.nsol_14 = &mylist_B0;
         } else {
-#line 4470
-            CError_ASSERT(pr2.nsol_14);
+            CError_ASSERT(4470, pr2.nsol_14);
         }
 
         if (token != '=' || (pr2.bcl_18->type == left->rtype && pr2.bcl_18->next == NULL)) {
@@ -3406,15 +3375,13 @@ ENode *CExpr_ConstructObject(TypeClass *tclass, ENode *addr_expr, ENodeList *arg
     NameSpaceObjectList *ctorlist;
     BClassList path;
 
-#line 4595
-    CError_ASSERT(IS_TYPE_POINTER_ONLY(addr_expr->rtype));
+    CError_ASSERT(4595, IS_TYPE_POINTER_ONLY(addr_expr->rtype));
 
     addr_expr = makemonadicnode(addr_expr, EINDIRECT);
     addr_expr->rtype = TYPE(tclass);
 
     if (!flag3 && args && !args->next && args->node->rtype == TYPE(tclass) && !CClass_CopyConstructor(tclass)) {
-#line 4605
-        CError_ASSERT(IS_TYPE_CLASS(addr_expr->rtype));
+        CError_ASSERT(4605, IS_TYPE_CLASS(addr_expr->rtype));
         expr = makediadicnode(addr_expr, args->node, EASS);
         if (!flag1)
             expr = getnodeaddress(expr, 0);
@@ -3502,8 +3469,7 @@ static ENode *CExpr_CopyPlacementNewArg(ENodeList *list) {
 
     switch (list->node->rtype->type) {
         default:
-#line 4726
-            CError_FATAL();
+            CError_FATAL(4726);
         case TYPEINT:
         case TYPEFLOAT:
         case TYPEENUM:
@@ -3523,12 +3489,10 @@ static ENode *CExpr_PlacementDeleteCall(Type *type, ENode *expr, Object *obj, Bo
     ENodeList *inputarg;
     Boolean outflag;
 
-#line 4752
-    CError_ASSERT(ENODE_IS(expr, EFUNCCALL) && ENODE_IS(expr->data.funccall.funcref, EOBJREF));
+    CError_ASSERT(4752, ENODE_IS(expr, EFUNCCALL) && ENODE_IS(expr->data.funccall.funcref, EOBJREF));
 
     funcobj = expr->data.funccall.funcref->data.objref;
-#line 4756
-    CError_ASSERT(IS_TYPE_FUNC(funcobj->type) && TYPE_FUNC(funcobj->type)->args && TYPE_FUNC(funcobj->type)->args->next);
+    CError_ASSERT(4756, IS_TYPE_FUNC(funcobj->type) && TYPE_FUNC(funcobj->type)->args && TYPE_FUNC(funcobj->type)->args->next);
 
     funcobj = CParser_FindDeallocationObject(type, TYPE_FUNC(funcobj->type)->args->next, flag1, flag2, &outflag);
     if (!funcobj)
@@ -3546,8 +3510,7 @@ static ENode *CExpr_PlacementDeleteCall(Type *type, ENode *expr, Object *obj, Bo
     list->node = create_objectnode(obj);
     result->data.funccall.args = list;
 
-#line 4780
-    CError_ASSERT((inputarg = expr->data.funccall.args) && (inputarg = inputarg->next));
+    CError_ASSERT(4780, (inputarg = expr->data.funccall.args) && (inputarg = inputarg->next));
 
     do {
         list->next = lalloc(sizeof(ENodeList));
@@ -3688,12 +3651,10 @@ static ENode *CExpr_NewAlloc(Type *type, ENodeList *args, Boolean flag1, Boolean
         if (CScope_FindClassMemberObject(TYPE_CLASS(type), &pr, name)) {
             list = pr.nsol_14;
             obj = OBJECT(pr.obj_10);
-#line 4935
-            CError_ASSERT(list || obj);
+            CError_ASSERT(4935, list || obj);
             found = 1;
         } else if (TYPE_CLASS(type)->flags & CLASS_FLAGS_1) {
-#line 4942
-            CError_ASSERT(!flag2);
+            CError_ASSERT(4942, !flag2);
             obj = newh_func;
             found = 1;
         }
@@ -3764,8 +3725,7 @@ static ENode *CExpr_NewExceptionSafeInit(ENode *expr, ENode *tryexpr) {
             expr->data.itc.tryexpr = tryexpr;
             break;
         default:
-#line 5056
-            CError_FATAL();
+            CError_FATAL(5056);
     }
     return expr;
 }
@@ -3834,7 +3794,7 @@ static ENode *CExpr_NewArray(Type *type, UInt32 qual, ENodeList *nodelist, Boole
 
     dtor = CClass_Destructor(TYPE_CLASS(innertype));
     if (dtor)
-        dtor = CABI_GetDestructorObject(dtor, 1);
+        dtor = CABI_GetDestructorObject(dtor, CABIDestroy1);
 
     ass = NULL;
     if (firstarrayexpr) {
@@ -4223,8 +4183,7 @@ ENode *scandelete(Boolean flag) {
     if (!flag) {
         result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 1);
     } else {
-#line 5650
-        CError_ASSERT(!outflag);
+        CError_ASSERT(5650, !outflag);
         result_expr = CABI_DestroyObject(dtor, expr, 2, 0, 0);
         result_expr->rtype = TYPE(&void_ptr);
         result_expr = funccallexpr(obj, result_expr, NULL, NULL, NULL);
diff --git a/compiler_and_linker/unsorted/CExprConvMatch.c b/compiler_and_linker/unsorted/CExprConvMatch.c
index 9722dcb..7fdce02 100644
--- a/compiler_and_linker/unsorted/CExprConvMatch.c
+++ b/compiler_and_linker/unsorted/CExprConvMatch.c
@@ -1 +1,2518 @@
 #include "compiler/CExpr.h"
+#include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CInt64.h"
+#include "compiler/CFunc.h"
+#include "compiler/CMachine.h"
+#include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CScope.h"
+#include "compiler/CTemplateFunc.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
+#include "compiler/templates.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct StandardConv {
+    Type *type1;
+    Type *type2;
+    UInt32 qual1;
+    UInt32 qual2;
+    Boolean x10; // unknown
+    Boolean x11;
+    Boolean x12;
+    Boolean x13;
+    Boolean x14;
+    Boolean x15;
+} StandardConv;
+
+typedef enum EImplicitConvType {
+    ICT_0,
+    ICT_1,
+    ICT_2,
+    ICT_3
+} EImplicitConvType;
+
+typedef struct ImplicitConv {
+    EImplicitConvType type;
+    union {
+        struct {
+            Object *x2;
+            StandardConv standardConv;
+        } ic2;
+        struct {
+            StandardConv standardConv;
+        } ic3;
+    } u;
+} ImplicitConv;
+
+typedef struct ConversionTypeList {
+    struct ConversionTypeList *next;
+    Object *func;
+    Type *type;
+    UInt32 qual;
+} ConversionTypeList;
+
+typedef struct Match {
+    struct Match *next;
+    Object *object;
+    Object *specialfunc;
+    Type *type;
+    UInt32 qual;
+    Type *type2;
+    UInt32 qual2;
+    ImplicitConv conv[3];
+} Match;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
+// forward decls
+static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean flag2, Boolean flag3);
+
+static Type *CExpr_GetImplictObjectParamType(Object *object, UInt32 *qual) {
+    Type *type;
+
+    CError_ASSERT(98, IS_TYPE_FUNC(object->type));
+    CError_ASSERT(99, TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD);
+    CError_ASSERT(100, !TYPE_METHOD(object->type)->x26);
+    CError_ASSERT(101, TYPE_METHOD(object->type)->args);
+
+    type = CDecl_NewRefPointerType(TYPE(TYPE_METHOD(object->type)->theclass));
+    *qual = TYPE_METHOD(object->type)->args->qual & Q_CV;
+    return type;
+}
+
+static Type *CExpr_GetParamType(Object *object, int index, UInt32 *qual) {
+    FuncArg *arg;
+
+    CError_ASSERT(120, IS_TYPE_FUNC(object->type));
+    CError_ASSERT(121, arg = TYPE_FUNC(object->type)->args);
+    if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
+        CError_ASSERT(125, arg = arg->next);
+
+    while (index > 0) {
+        CError_ASSERT(129, arg = arg->next);
+        index--;
+    }
+
+    *qual = arg->qual & Q_CV;
+    return arg->type;
+}
+
+static Boolean CExpr_HasNParams(Object *object, int count) {
+    FuncArg *arg;
+    int i;
+
+    CError_ASSERT(146, IS_TYPE_FUNC(object->type));
+    CError_ASSERT(147, arg = TYPE_FUNC(object->type)->args);
+    if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type)))
+        arg = arg->next;
+
+    i = 0;
+    while (arg) {
+        arg = arg->next;
+        i++;
+    }
+
+    return i == count;
+}
+
+typedef enum TypeCompareMode {
+    TCM_0,
+    TCM_1,
+    TCM_2
+} TypeCompareMode;
+
+static Boolean CExpr_TypeCompare(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB, TypeCompareMode mode) {
+    if (typeA->type != typeB->type)
+        return 0;
+
+    switch (mode) {
+        case TCM_0:
+            while (1) {
+                switch (typeA->type) {
+                    case TYPEPOINTER:
+                        typeA = TPTR_TARGET(typeA);
+                        typeB = TPTR_TARGET(typeB);
+                        if (typeA->type != typeB->type)
+                            return 0;
+                        continue;
+
+                    case TYPEMEMBERPOINTER:
+                        if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
+                            return 0;
+                        typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
+                        typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
+                        if (typeA->type != typeB->type)
+                            return 0;
+                        continue;
+                }
+                break;
+            }
+            break;
+
+        case TCM_1:
+            switch (typeA->type) {
+                case TYPEPOINTER:
+                    if ((qualA & Q_CV) != (qualB & Q_CV))
+                        return 0;
+
+                    typeA = TPTR_TARGET(typeA);
+                    typeB = TPTR_TARGET(typeB);
+                    break;
+
+                case TYPEMEMBERPOINTER:
+                    if ((qualA & Q_CV) != (qualB & Q_CV))
+                        return 0;
+
+                    if (!is_typesame(TYPE_MEMBER_POINTER(typeA)->ty2, TYPE_MEMBER_POINTER(typeB)->ty2))
+                        return 0;
+                    typeA = TYPE_MEMBER_POINTER(typeA)->ty1;
+                    typeB = TYPE_MEMBER_POINTER(typeB)->ty1;
+                    break;
+            }
+            break;
+
+        case TCM_2:
+            if ((qualA & Q_CV) != (qualB & Q_CV))
+                return 0;
+            break;
+    }
+
+    return is_typesame(typeA, typeB);
+}
+
+static int CExpr_IsReferenceCompatible(Type *typeA, UInt32 qualA, Type *typeB, UInt32 qualB) {
+    if (CParser_IsSameOrMoreCVQualified(CParser_GetCVTypeQualifiers(typeA, qualA), CParser_GetCVTypeQualifiers(typeB, qualB))) {
+        if (CExpr_TypeCompare(typeA, qualA, typeB, qualB, TCM_1))
+            return 1;
+
+        if (IS_TYPE_CLASS(typeB) && IS_TYPE_CLASS(typeA)) {
+            short depth;
+            Boolean isambigbase;
+            if (CClass_GetBasePath(TYPE_CLASS(typeB), TYPE_CLASS(typeA), &depth, &isambigbase))
+                return 2;
+        }
+    }
+
+    return 0;
+}
+
+static Boolean CExpr_IsBaseOf(TypeClass *baseclass, TypeClass *superclass) {
+    ClassList *base;
+
+    for (base = superclass->bases; base; base = base->next) {
+        if (base->base == baseclass || CExpr_IsBaseOf(baseclass, base->base))
+            return 1;
+    }
+
+    return 0;
+}
+
+static Boolean CExpr_IsBetterClassConversion(TypeClass *a, TypeClass *b, TypeClass *c, TypeClass *d) {
+    if (a == c)
+        return CExpr_IsBaseOf(d, b);
+    if (b == d)
+        return CExpr_IsBaseOf(a, c);
+    return 0;
+}
+
+inline Boolean Inline_501D40(Type *a, Type *b) {
+    return (a == TYPE(&stbool)) && (IS_TYPE_POINTER_ONLY(b) || IS_TYPE_MEMBERPOINTER(b));
+}
+
+static Boolean CExpr_IsBetterStandardConv(StandardConv *a, StandardConv *b) {
+    Boolean flag10;
+    Boolean flag3;
+
+    flag10 = 1;
+    flag3 = 0;
+
+    if (b->x11) {
+        if (!a->x11)
+            flag3 = 1;
+    } else {
+        if (a->x11)
+            flag10 = 0;
+    }
+
+    if (b->x12) {
+        if (!a->x12)
+            flag3 = 1;
+    } else {
+        if (a->x12)
+            flag10 = 0;
+    }
+
+    if (b->x13) {
+        if (a->x13) {
+            if (Inline_501D40(b->type2, b->type1)) {
+                if (!Inline_501D40(a->type2, a->type1))
+                    return 1;
+            } else {
+                if (Inline_501D40(a->type2, a->type1))
+                    return 0;
+            }
+        } else {
+            flag3 = 1;
+        }
+    } else {
+        if (a->x13)
+            flag10 = 0;
+    }
+
+    if (flag10 && flag3)
+        return 1;
+
+    if (!a->x13) {
+        if (b->x13)
+            return 1;
+
+        if (a->x12) {
+            if (!b->x12)
+                return 0;
+        } else {
+            if (b->x12)
+                return 1;
+        }
+    } else {
+        if (!b->x13)
+            return 0;
+    }
+
+    if (
+        IS_TYPE_POINTER_ONLY(a->type1) &&
+        IS_TYPE_CLASS(TPTR_TARGET(a->type1)) &&
+        IS_TYPE_POINTER_ONLY(a->type2) &&
+        IS_TYPE_POINTER_ONLY(b->type1) &&
+        IS_TYPE_CLASS(TPTR_TARGET(b->type1)) &&
+        IS_TYPE_POINTER_ONLY(b->type2)
+        )
+    {
+        if (TPTR_TARGET(b->type2) == &stvoid) {
+            if (TPTR_TARGET(a->type2) == &stvoid) {
+                if (CExpr_IsBaseOf(TYPE_CLASS(TPTR_TARGET(a->type1)), TYPE_CLASS(TPTR_TARGET(b->type1))))
+                    return 1;
+            } else {
+                if (TPTR_TARGET(a->type1) == TPTR_TARGET(b->type1) && IS_TYPE_CLASS(TPTR_TARGET(a->type2)))
+                    return 1;
+            }
+        } else if (IS_TYPE_CLASS(TPTR_TARGET(a->type2)) && IS_TYPE_CLASS(TPTR_TARGET(b->type2))) {
+            if (CExpr_IsBetterClassConversion(
+                TYPE_CLASS(TPTR_TARGET(a->type1)),
+                TYPE_CLASS(TPTR_TARGET(a->type2)),
+                TYPE_CLASS(TPTR_TARGET(b->type1)),
+                TYPE_CLASS(TPTR_TARGET(b->type2))
+                ))
+                return 1;
+        }
+    }
+
+    if (
+        IS_TYPE_CLASS(a->type1) &&
+        IS_TYPE_CLASS(a->type2) &&
+        IS_TYPE_CLASS(b->type1) &&
+        IS_TYPE_CLASS(b->type2) &&
+        CExpr_IsBetterClassConversion(
+            TYPE_CLASS(a->type1),
+            TYPE_CLASS(a->type2),
+            TYPE_CLASS(b->type1),
+            TYPE_CLASS(b->type2)
+        )
+        )
+        return 1;
+
+    if (
+        IS_TYPE_MEMBERPOINTER(a->type1) &&
+        IS_TYPE_MEMBERPOINTER(a->type2) &&
+        IS_TYPE_MEMBERPOINTER(b->type1) &&
+        IS_TYPE_MEMBERPOINTER(b->type2) &&
+        IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2) &&
+        IS_TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2) &&
+        IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2) &&
+        IS_TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2) &&
+        CExpr_IsBetterClassConversion(
+            TYPE_CLASS(TYPE_MEMBER_POINTER(b->type1)->ty2),
+            TYPE_CLASS(TYPE_MEMBER_POINTER(b->type2)->ty2),
+            TYPE_CLASS(TYPE_MEMBER_POINTER(a->type1)->ty2),
+            TYPE_CLASS(TYPE_MEMBER_POINTER(a->type2)->ty2)
+        )
+        )
+        return 1;
+
+    if (
+        a->x14 &&
+        b->x14 &&
+        CExpr_TypeCompare(a->type2, a->qual2, b->type2, b->qual2, TCM_1) &&
+        CParser_IsMoreCVQualified(
+            CParser_GetTypeQualifiers(b->type2, b->qual2),
+            CParser_GetTypeQualifiers(a->type2, a->qual2)
+        )
+        )
+        return 1;
+
+    return 0;
+}
+
+static Boolean CExpr_IsBetterImplicitConv(ImplicitConv *a, ImplicitConv *b) {
+    if (a->type > b->type)
+        return 1;
+    if (a->type != b->type)
+        return 0;
+
+    if (a->type == ICT_3)
+        return CExpr_IsBetterStandardConv(&a->u.ic3.standardConv, &b->u.ic3.standardConv);
+
+    if (a->type == ICT_2 && a->u.ic2.x2 == b->u.ic2.x2 && CExpr_IsBetterStandardConv(&a->u.ic2.standardConv, &b->u.ic2.standardConv))
+        return 1;
+
+    return 0;
+}
+
+typedef enum SSCRMode {
+    SSCR_0,
+    SSCR_1,
+    SSCR_2
+} SSCRMode;
+
+static Boolean CExpr_SetupStandardConversionResult(ENode *expr, Type *type2, UInt32 qual2, SSCRMode mode, Boolean x14, Boolean refFlag, StandardConv *result) {
+    UInt32 cv1;
+    UInt32 cv2;
+
+    if (x14) {
+        if (!CParser_IsConst(type2, qual2)) {
+            if (!refFlag && !CExpr_IsLValue(expr))
+                return 0;
+            if (mode != SSCR_0 && !IS_TYPE_CLASS(type2))
+                return 0;
+        }
+
+        cv2 = CParser_GetTypeQualifiers(type2, qual2) & Q_CV;
+        cv1 = CParser_GetTypeQualifiers(expr->rtype, ENODE_QUALS(expr)) & Q_CV;
+        if (cv2 != cv1 && !CParser_IsMoreCVQualified(cv2, cv1))
+            return 0;
+    }
+
+    memclrw(result, sizeof(StandardConv));
+    result->type2 = type2;
+    result->qual2 = qual2;
+    result->type1 = expr->rtype;
+    result->qual1 = ENODE_QUALS(expr);
+    result->x14 = x14;
+
+    switch (mode) {
+        case SSCR_0:
+            break;
+        case SSCR_1:
+            result->x12 = 1;
+            break;
+        case SSCR_2:
+            result->x13 = 1;
+            break;
+        default:
+            CError_FATAL(581);
+    }
+
+    return 1;
+}
+
+typedef enum MysteryEnum {
+    ME_0,
+    ME_1,
+    ME_255 = 255
+} MysteryEnum;
+
+inline MysteryEnum Inline_501FF0(UInt32 qual1, UInt32 qual2) {
+    if ((qual1 & Q_CV) == (qual2 & Q_CV))
+        return ME_0;
+
+    if (((qual2 & Q_CONST) && !(qual1 & Q_CONST)) || ((qual2 & Q_VOLATILE) && !(qual1 & Q_VOLATILE)))
+        return ME_255;
+
+    return ME_1;
+}
+
+static Boolean CExpr_SetQualConversionResult(Type *type1, UInt32 qual1, Type *type2, UInt32 qual2, StandardConv *result) {
+    Boolean flag = 1;
+    UInt32 cv1;
+    UInt32 cv2;
+
+    while (1) {
+        cv1 = CParser_GetCVTypeQualifiers(type1, qual1);
+        cv2 = CParser_GetCVTypeQualifiers(type2, qual2);
+
+        switch (Inline_501FF0(cv1, cv2)) {
+            case ME_0:
+                break;
+
+            case ME_1:
+                result->x11 = 1;
+                if (!flag)
+                    return 0;
+                break;
+
+            default:
+                return 0;
+        }
+
+        if (!(cv1 & Q_CONST))
+            flag = 0;
+
+        if (IS_TYPE_POINTER_ONLY(type1)) {
+            CError_ASSERT(635, IS_TYPE_POINTER_ONLY(type2));
+            type1 = TPTR_TARGET(type1);
+            type2 = TPTR_TARGET(type2);
+        } else {
+            if (!IS_TYPE_MEMBERPOINTER(type1))
+                return 1;
+
+            CError_ASSERT(642, IS_TYPE_MEMBERPOINTER(type2));
+            type1 = TYPE_MEMBER_POINTER(type1)->ty1;
+            type2 = TYPE_MEMBER_POINTER(type2)->ty1;
+        }
+    }
+}
+
+static Boolean CExpr_OverloadFuncMatch(NameSpaceObjectList *list, TemplArg *templargs, Type *type, ENode **outExpr) {
+    Object *object;
+    TemplFuncInstance *inst;
+    ENode *expr;
+    FuncArg *arg;
+    int i;
+    ObjectList *objlist;
+    Object *object26;
+    ObjectList *objlist25;
+    ObjectList *objlist24;
+    Boolean flag23;
+
+    if (!IS_TYPE_POINTER_ONLY(type) || !IS_TYPE_FUNC(type = TPTR_TARGET(type)))
+        return 0;
+
+    object26 = NULL;
+    objlist25 = NULL;
+    objlist24 = NULL;
+    flag23 = 0;
+
+    while (list) {
+        object = OBJECT(list->object);
+        if (object->otype == OT_OBJECT) {
+            if (IS_TEMPL_FUNC(object->type)) {
+                if (!flag23 && CTempl_CanDeduceFunc(object, TYPE_FUNC(type), templargs)) {
+                    CError_ASSERT(685, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
+                    if (is_typesame(inst->object->type, type)) {
+                        objlist = lalloc(sizeof(ObjectList));
+                        objlist->next = objlist24;
+                        objlist->object = object;
+                        objlist24 = objlist;
+
+                        if (object26 && object26 != inst->object) {
+                            objlist = lalloc(sizeof(ObjectList));
+                            objlist->next = objlist25;
+                            objlist->object = inst->object;
+                            objlist25 = objlist;
+                        } else {
+                            object26 = inst->object;
+                        }
+                    }
+                }
+            } else if (is_typesame(object->type, type)) {
+                if (object26 && flag23) {
+                    Object *checkA, *checkB;
+                    checkA = object;
+                    if (checkA->datatype == DALIAS)
+                        checkA = checkA->u.alias.object;
+                    checkB = object26;
+                    if (checkB->datatype == DALIAS)
+                        checkB = checkB->u.alias.object;
+                    if (checkA != checkB) {
+                        objlist = lalloc(sizeof(ObjectList));
+                        objlist->next = objlist25;
+                        objlist->object = object;
+                        objlist25 = objlist;
+                    }
+                } else {
+                    objlist25 = NULL;
+                    object26 = object;
+                }
+                flag23 = 1;
+            }
+        }
+        list = list->next;
+    }
+
+    if (object26) {
+        if (outExpr) {
+            if (objlist25) {
+                i = 0;
+                for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next)
+                    i++;
+
+                if (!flag23 && (object = CTempl_PartialOrdering(objlist24->object, objlist24->next, i))) {
+                    CError_ASSERT(741, inst = CTempl_DeduceFunc(object, TYPE_FUNC(type), templargs, NULL, 0));
+                    object26 = inst->object;
+                } else {
+                    CError_OverloadedFunctionError(object26, objlist25);
+                }
+            }
+
+            expr = CExpr_MakeObjRefNode(object26, 1);
+            *outExpr = expr;
+            expr->rtype = CDecl_NewPointerType(object26->type);
+            expr->flags = object->qual & ENODE_FLAG_QUALS;
+            object26->flags |= OBJECT_FLAGS_UNUSED;
+            if (object26->datatype == DINLINEFUNC)
+                CError_Error(CErrorStr175);
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+static Boolean CExpr_StandardConversionMatch(ENode *expr, Type *type2, UInt32 qual2, Boolean x14, StandardConv *result) {
+    Type *type1;
+    UInt32 qual1;
+    Boolean refFlag;
+    Type *inner2;
+    Type *inner1;
+    SSCRMode mode;
+    NameSpaceObjectList list;
+
+    if (IS_TYPE_REFERENCE(type2)) {
+        type2 = TPTR_TARGET(type2);
+        if (IS_TYPE_POINTER_ONLY(type2))
+            expr = pointer_generation(expr);
+        refFlag = 1;
+    } else {
+        if (
+            (IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type2)) ||
+            (IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type2))
+            )
+            expr = pointer_generation(expr);
+        refFlag = 0;
+    }
+
+    type1 = expr->rtype;
+    qual1 = ENODE_QUALS(expr);
+
+    if (IS_TYPE_POINTER_ONLY(type2)) {
+        if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
+            if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
+                return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+        }
+
+        if (
+            IS_TYPE_INT(expr->rtype) &&
+            ENODE_IS_INDIRECT_TO(expr, EOBJREF) &&
+            (expr->data.monadic->data.objref->qual & Q_10000) &&
+            CInt64_IsZero(&expr->data.monadic->data.objref->u.data.u.intconst)
+            )
+            return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+
+        if (ENODE_IS(expr, EOBJLIST))
+            return CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type2, NULL) &&
+                   CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+
+        if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
+            list.next = NULL;
+            list.object = OBJ_BASE(expr->data.objref);
+            return CExpr_OverloadFuncMatch(&list, NULL, type2, NULL) &&
+                   CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+        }
+
+        if (IS_TYPE_POINTER_ONLY(type1)) {
+            if (
+                ENODE_IS(expr, ESTRINGCONST) &&
+                TPTR_TARGET(type2) == TPTR_TARGET(type1) &&
+                !(qual2 & Q_CONST) &&
+                (
+                    TPTR_TARGET(type2) == TYPE(&stchar) ||
+                    TPTR_TARGET(type2) == TYPE(&stunsignedchar) ||
+                    TPTR_TARGET(type2) == CParser_GetWCharType()
+                    )
+                )
+            {
+                if (
+                    CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result) &&
+                    CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1 & ~Q_CONST, result)
+                    )
+                {
+                    result->x11 = 1;
+                    return 1;
+                } else {
+                    return 0;
+                }
+            }
+
+            if (copts.objective_c && CObjC_IsCompatibleType(expr->rtype, type2))
+                return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, x14, refFlag, result);
+
+            if (IS_TYPE_VOID(TPTR_TARGET(type2)) || (!copts.cplusplus && IS_TYPE_VOID(TPTR_TARGET(type1)))) {
+                if (CExpr_SetupStandardConversionResult(expr, type2, qual2, IS_TYPE_VOID(TPTR_TARGET(type1)) ? SSCR_0 : SSCR_2, refFlag, x14, result)) {
+                    switch (Inline_501FF0(qual2, CParser_GetCVTypeQualifiers(TPTR_TARGET(type1), qual1))) {
+                        case ME_1:
+                            result->x11 = 1;
+                        case ME_0:
+                            return 1;
+                        default:
+                            return 0;
+                    }
+                } else {
+                    return 0;
+                }
+            }
+
+            inner2 = TPTR_TARGET(type2);
+            inner1 = TPTR_TARGET(type1);
+            while (1) {
+                if (inner2->type != inner1->type)
+                    break;
+
+                switch (inner2->type) {
+                    case TYPEPOINTER:
+                        inner2 = TPTR_TARGET(inner2);
+                        inner1 = TPTR_TARGET(inner1);
+                        continue;
+                    case TYPEMEMBERPOINTER:
+                        if (!is_typesame(TYPE_MEMBER_POINTER(inner2)->ty2, TYPE_MEMBER_POINTER(inner1)->ty2))
+                            break;
+
+                        inner2 = TYPE_MEMBER_POINTER(inner2)->ty1;
+                        inner1 = TYPE_MEMBER_POINTER(inner1)->ty1;
+                        if (!IS_TYPE_POINTER_ONLY(inner2) && !IS_TYPE_MEMBERPOINTER(inner2)) {
+                            if (!is_memberpointerequal(inner2, inner1))
+                                break;
+
+                            if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
+                                return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+                            else
+                                return 0;
+                        }
+                        continue;
+                    default:
+                        if (!is_typesame(inner2, inner1))
+                            break;
+
+                        if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result))
+                            return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+                        else
+                            return 0;
+                }
+
+                break;
+            }
+
+            if (IS_TYPE_CLASS(TPTR_TARGET(type2)) && IS_TYPE_CLASS(TPTR_TARGET(type1))) {
+                short depth;
+                Boolean isambigbase;
+                if (CClass_GetBasePath(TYPE_CLASS(TPTR_TARGET(type1)), TYPE_CLASS(TPTR_TARGET(type2)), &depth, &isambigbase)) {
+                    if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+                        return CExpr_SetQualConversionResult(TPTR_TARGET(type2), qual2, TPTR_TARGET(type1), qual1, result);
+                    else
+                        return 0;
+                }
+            }
+        }
+
+        if (copts.mpwc_relax && !copts.cplusplus && IS_TYPE_POINTER_ONLY(type1)) {
+            if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+                return 1;
+        }
+
+        return 0;
+    }
+
+    if (is_typesame(type2, type1))
+        return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_0, refFlag, x14, result);
+
+    if (type2 == TYPE(&stbool)) {
+        switch (type1->type) {
+            case TYPEINT:
+            case TYPEFLOAT:
+            case TYPEENUM:
+            case TYPEMEMBERPOINTER:
+            case TYPEPOINTER:
+                return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
+            default:
+                return 0;
+        }
+    }
+
+    if (IS_TYPE_MEMBERPOINTER(type2)) {
+        if (ENODE_IS(expr, EINTCONST) && CInt64_IsZero(&expr->data.intval)) {
+            if (IS_TYPE_INT(type1) || (!copts.cplusplus && IS_TYPE_ENUM(type1)))
+                return CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result);
+        }
+
+        if (ENODE_IS(expr, EMEMBER)) {
+            expr = getpointertomemberfunc(expr, type2, 0);
+            type1 = expr->rtype;
+        }
+
+        if (IS_TYPE_MEMBERPOINTER(type1)) {
+            short depth;
+            Boolean isambigbase;
+
+            CError_ASSERT(996, IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2) && IS_TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2));
+            if (!is_memberpointerequal(TYPE_MEMBER_POINTER(type2)->ty1, TYPE_MEMBER_POINTER(type1)->ty1))
+                return 0;
+
+            if (
+                TYPE_MEMBER_POINTER(type2)->ty2 == TYPE_MEMBER_POINTER(type1)->ty2 ||
+                CClass_GetBasePath(TYPE_CLASS(TYPE_MEMBER_POINTER(type2)->ty2), TYPE_CLASS(TYPE_MEMBER_POINTER(type1)->ty2), &depth, &isambigbase)
+                )
+            {
+                if (CExpr_SetupStandardConversionResult(expr, type2, qual2, SSCR_2, refFlag, x14, result))
+                    return CExpr_SetQualConversionResult(TYPE_MEMBER_POINTER(type2)->ty1, qual2, TYPE_MEMBER_POINTER(type1)->ty1, qual1, result);
+                else
+                    return 0;
+            }
+        }
+
+        return 0;
+    }
+
+    mode = SSCR_2;
+    switch (type1->type) {
+        case TYPEINT:
+            switch (type2->type) {
+                case TYPEINT:
+                    if (TYPE_INTEGRAL(type1)->integral < IT_INT) {
+                        if (type2 == TYPE(&stsignedint)) {
+                            if (type1->size < type2->size || !is_unsigned(type1))
+                                mode = SSCR_1;
+                        } else if (type2 == TYPE(&stunsignedint)) {
+                            if (type2->size == type1->size && is_unsigned(type1))
+                                mode = SSCR_1;
+                        }
+                    }
+                    break;
+                case TYPEFLOAT:
+                    break;
+                case TYPEENUM:
+                    if (copts.cplusplus)
+                        return 0;
+                    break;
+                default:
+                    return 0;
+            }
+            break;
+
+        case TYPEFLOAT:
+            switch (type2->type) {
+                case TYPEINT:
+                    break;
+                case TYPEFLOAT:
+                    if (type2 == TYPE(&stdouble)) {
+                        if (type1 == TYPE(&stfloat) || type1 == TYPE(&stshortdouble))
+                            mode = SSCR_1;
+                    }
+                    break;
+                case TYPEENUM:
+                    if (copts.cplusplus)
+                        return 0;
+                    break;
+                default:
+                    return 0;
+            }
+            break;
+
+        case TYPEENUM:
+            switch (type2->type) {
+                case TYPEINT:
+                    if (TYPE_INTEGRAL(TYPE_ENUM(expr->rtype)->enumtype)->integral < IT_INT) {
+                        if (type1->size == type2->size && is_unsigned(TYPE_ENUM(type1)->enumtype)) {
+                            if (type2 == TYPE(&stunsignedint))
+                                mode = SSCR_1;
+                        } else {
+                            if (type2 == TYPE(&stsignedint))
+                                mode = SSCR_1;
+                        }
+                    } else {
+                        if (TYPE_ENUM(type1)->enumtype == type2)
+                            mode = SSCR_1;
+                    }
+                    break;
+                case TYPEFLOAT:
+                    break;
+                case TYPEENUM:
+                    if (copts.cplusplus)
+                        return 0;
+                    break;
+                default:
+                    return 0;
+            }
+            break;
+
+        case TYPECLASS: {
+            short depth;
+            Boolean isambigbase;
+
+            if (!IS_TYPE_CLASS(type1) || !CClass_GetBasePath(TYPE_CLASS(type1), TYPE_CLASS(type2), &depth, &isambigbase))
+                return 0;
+            break;
+        }
+
+        default:
+            return 0;
+    }
+
+    return CExpr_SetupStandardConversionResult(expr, type2, qual2, mode, refFlag, x14, result);
+}
+
+static ENode *CExpr_UserConversion(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result, Boolean flag1, Boolean isExplicit, Boolean flag3) {
+    Object *object28;
+    Object *object27;
+    Object *object26;
+    ObjectList *objlist25;
+    ObjectList *objlist24;
+    ObjectList *objlist;
+    TypeFunc *tfunc23;
+    Type *tmptype23;
+    NameSpaceObjectList *list22;
+    Boolean flag22;
+    Boolean flag21;
+    FuncArg *arg21;
+    Boolean flag20;
+    ENode *newExpr;
+    ENode *funcref;
+    ENode *tmpExpr;
+    ENodeList *arglist;
+    UInt32 q1;
+    UInt32 q2;
+    StandardConv sc3;
+    StandardConv sc2;
+    StandardConv sc1;
+    ConversionIterator convIter;
+    ENodeList myarglist;
+    ObjectList myobjlist;
+    BClassList path;
+
+    object28 = NULL;
+    object27 = NULL;
+    objlist25 = NULL;
+    objlist24 = NULL;
+
+    if (type2->size == 0)
+        CDecl_CompleteType(type2);
+    if (expr->rtype->size == 0)
+        CDecl_CompleteType(expr->rtype);
+
+    if (IS_TYPE_CLASS(expr->rtype)) {
+        CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
+        flag22 = 1;
+        while ((object26 = CExpr_ConversionIteratorNext(&convIter))) {
+            tfunc23 = TYPE_FUNC(object26->type);
+            if (tfunc23->flags & FUNC_FLAGS_100000) {
+                object26 = CTempl_DeduceFromConversion(object26, type2, qual2);
+                if (!object26)
+                    continue;
+                tfunc23 = TYPE_FUNC(object26->type);
+            }
+
+            if (flag3) {
+                if (
+                    !IS_TYPE_REFERENCE(tfunc23->functype) ||
+                    !CExpr_IsReferenceCompatible(type2, qual2, TPTR_TARGET(tfunc23->functype), tfunc23->qual)
+                    )
+                    continue;
+            }
+
+            CError_ASSERT(1230, tfunc23->args && IS_TYPE_POINTER_ONLY(tfunc23->args->type));
+
+            q1 = ENODE_QUALS(expr);
+            q2 = tfunc23->args->qual;
+            if ((q1 & Q_CV) != (q2 & Q_CV)) {
+                if (!flag22)
+                    continue;
+                if ((q1 & Q_CONST) && !(q2 & Q_CONST))
+                    continue;
+                if ((q1 & Q_VOLATILE) && !(q2 & Q_VOLATILE))
+                    continue;
+                flag21 = 1;
+            } else {
+                flag21 = 0;
+            }
+
+            newExpr = CExpr_NewENode(ETEMP);
+            newExpr->rtype = tfunc23->functype;
+            newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
+            flag20 = 0;
+
+            if (IS_TYPE_REFERENCE(newExpr->rtype)) {
+                newExpr->rtype = TPTR_TARGET(newExpr->rtype);
+                if (!CParser_IsConst(newExpr->rtype, tfunc23->qual)) {
+                    newExpr = makemonadicnode(newExpr, EINDIRECT);
+                    newExpr->data.monadic->rtype = TYPE(&void_ptr);
+                    newExpr = makemonadicnode(newExpr, EINDIRECT);
+                    newExpr->data.monadic->rtype = TYPE(&void_ptr);
+                    flag20 = 1;
+                }
+            }
+
+            if (CExpr_StandardConversionMatch(newExpr, type2, qual2, 0, &sc1)) {
+                if (flag22 && !flag21) {
+                    object28 = NULL;
+                    objlist25 = NULL;
+                    flag22 = 0;
+                }
+
+                if (object28 && object28 != object26) {
+                    if (CExpr_IsBetterStandardConv(&sc3, &sc1))
+                        continue;
+
+                    if (!CExpr_IsBetterStandardConv(&sc1, &sc3)) {
+                        objlist = lalloc(sizeof(ObjectList));
+                        objlist->next = objlist25;
+                        objlist->object = object28;
+                        objlist25 = objlist;
+                    } else {
+                        objlist25 = NULL;
+                    }
+                }
+
+                object28 = object26;
+                sc3 = sc1;
+                sc3.x15 = flag20;
+            }
+        }
+    }
+
+    if (!flag3 && IS_TYPE_CLASS(type2) && (list22 = CClass_Constructor(TYPE_CLASS(type2)))) {
+        for (; list22; list22 = list22->next) {
+            object26 = OBJECT(list22->object);
+            if (
+                object26->otype == OT_OBJECT &&
+                IS_TYPE_FUNC(tfunc23 = TYPE_FUNC(object26->type)) &&
+                (isExplicit || !(object26->qual & Q_EXPLICIT))
+                )
+            {
+                if (tfunc23->flags & FUNC_FLAGS_100000) {
+                    myarglist.next = NULL;
+                    myarglist.node = expr;
+                    object26 = CTempl_DeduceFromFunctionCall(object26, NULL, &myarglist);
+                    if (!object26)
+                        continue;
+                    tfunc23 = TYPE_FUNC(object26->type);
+                }
+
+                if (!(arg21 = tfunc23->args))
+                    continue;
+                if (!(arg21 = arg21->next))
+                    continue;
+                if ((TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) && !(arg21 = arg21->next))
+                    continue;
+                if (arg21 == &elipsis)
+                    continue;
+                if (arg21->next && !arg21->next->dexpr && arg21->next != &elipsis)
+                    continue;
+
+                tmptype23 = arg21->type;
+                if (IS_TYPE_REFERENCE(tmptype23)) {
+                    tmptype23 = TPTR_TARGET(tmptype23);
+                    if (!CParser_IsConst(tmptype23, arg21->qual) && !CExpr_IsLValue(expr))
+                        continue;
+                }
+
+                if (CExpr_StandardConversionMatch(expr, tmptype23, arg21->qual, 0, &sc1)) {
+                    if (object27) {
+                        if (!object26->u.func.inst && !object27->u.func.inst)
+                            continue;
+                        if (CExpr_IsBetterStandardConv(&sc2, &sc1))
+                            continue;
+
+                        if (!CExpr_IsBetterStandardConv(&sc1, &sc2)) {
+                            if (!object26->u.func.inst && object27->u.func.inst) {
+                                objlist24 = NULL;
+                            } else {
+                                objlist = lalloc(sizeof(ObjectList));
+                                objlist->next = objlist25;
+                                objlist->object = object28;
+                                objlist25 = objlist;
+                            }
+                        } else {
+                            objlist25 = NULL;
+                        }
+                    }
+
+                    object27 = object26;
+                    sc2 = sc1;
+                }
+            }
+        }
+    }
+
+    if (object28 && object27) {
+        if (!CExpr_IsBetterStandardConv(&sc2, &sc3)) {
+            if (!CExpr_IsBetterStandardConv(&sc3, &sc2)) {
+                if (result) {
+                    result->type = ICT_2;
+                    result->u.ic2.x2 = object28;
+                    result->u.ic2.standardConv = sc3;
+                }
+                if (flag1) {
+                    myobjlist.next = NULL;
+                    myobjlist.object = object27;
+                    CError_OverloadedFunctionError(object28, &myobjlist);
+                }
+            } else {
+                object27 = NULL;
+            }
+        } else {
+            object28 = NULL;
+        }
+    }
+
+    if (object28) {
+        if (result) {
+            result->type = ICT_2;
+            result->u.ic2.x2 = object28;
+            result->u.ic2.standardConv = sc3;
+        }
+        if (!flag1)
+            return expr;
+        if (objlist25)
+            CError_OverloadedFunctionError(object28, objlist25);
+        tfunc23 = TYPE_FUNC(object28->type);
+        CError_ASSERT(1416, IS_TYPEFUNC_METHOD(tfunc23));
+
+        funcref = create_objectrefnode(object28);
+        object28->flags |= OBJECT_FLAGS_UNUSED;
+
+        arglist = lalloc(sizeof(ENodeList));
+        arglist->next = NULL;
+
+        expr = getnodeaddress(expr, 0);
+        arglist->node = CExpr_AssignmentPromotion(
+            expr,
+            CDecl_NewPointerType(TYPE(TYPE_METHOD(tfunc23)->theclass)),
+            expr->flags,
+            0);
+
+        newExpr = lalloc(sizeof(ENode));
+        newExpr->type = EFUNCCALL;
+        newExpr->cost = 4;
+        newExpr->rtype = tfunc23->functype;
+        newExpr->flags = tfunc23->qual & ENODE_FLAG_QUALS;
+        newExpr->data.funccall.funcref = funcref;
+        newExpr->data.funccall.args = arglist;
+        newExpr->data.funccall.functype = TYPE_FUNC(object28->type);
+        newExpr = CExpr_AdjustFunctionCall(newExpr);
+        newExpr = checkreference(newExpr);
+
+        if (newExpr->rtype != type2) {
+            if (flag3) {
+                tmpExpr = CExpr_DerivedToBase(newExpr, type2, qual2, 1, 0, 1);
+                if (tmpExpr)
+                    return tmpExpr;
+            }
+            newExpr = CExpr_Convert(newExpr, type2, qual2, 0, 1);
+        }
+        return newExpr;
+    }
+
+    if (object27) {
+        if (result) {
+            result->type = ICT_2;
+            result->u.ic2.x2 = object27;
+            result->u.ic2.standardConv = sc2;
+        }
+        if (!flag1)
+            return expr;
+        if (objlist24)
+            CError_OverloadedFunctionError(object27, objlist24);
+
+        arglist = lalloc(sizeof(ENodeList));
+        arglist->next = NULL;
+        arglist->node = expr;
+
+        if (TYPE_CLASS(type2)->flags & CLASS_FLAGS_20) {
+            arglist->next = lalloc(sizeof(ENodeList));
+            arglist->next->node = expr;
+            arglist->next->next = NULL;
+            arglist->node = intconstnode(TYPE(&stsignedshort), 1);
+        }
+
+        path.next = NULL;
+        path.type = type2;
+
+        tmpExpr = makemonadicnode(create_temp_node(type2), EINDIRECT);
+        tmpExpr->rtype = type2;
+
+        newExpr = CExpr_GenericFuncCall(
+            &path, tmpExpr, 0, object27, NULL, NULL, arglist, 0, 0, 1
+            );
+
+        if (ENODE_IS2(newExpr, EFUNCCALL, EFUNCCALLP)) {
+            newExpr->rtype = CDecl_NewPointerType(type2);
+            newExpr = makemonadicnode(newExpr, EINDIRECT);
+            newExpr->rtype = type2;
+        }
+
+        return newExpr;
+    }
+
+    return NULL;
+}
+
+static Boolean CExpr_UserConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
+    Boolean flag;
+
+    if (IS_TYPE_REFERENCE(type2)) {
+        type2 = TPTR_TARGET(type2);
+        flag = !CParser_IsConst(type2, qual2);
+    } else {
+        expr = pointer_generation(expr);
+        flag = 0;
+    }
+
+    if (CExpr_UserConversion(expr, type2, qual2, result, 0, 0, flag))
+        return 1;
+
+    return 0;
+}
+
+static Boolean CExpr_ImplicitConversionMatch(ENode *expr, Type *type2, UInt32 qual2, ImplicitConv *result) {
+    if (CExpr_StandardConversionMatch(expr, type2, qual2, 0, &result->u.ic3.standardConv)) {
+        result->type = ICT_3;
+        return 1;
+    }
+
+    if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type2) || (IS_TYPE_REFERENCE(type2) && IS_TYPE_CLASS(TPTR_TARGET(type2)))) {
+        if (CExpr_UserConversionMatch(expr, type2, qual2, result)) {
+            result->type = ICT_2;
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+Boolean CExpr_CanImplicitlyConvert(ENode *expr, Type *type2, UInt32 qual2) {
+    ImplicitConv result;
+    return CExpr_ImplicitConversionMatch(expr, type2, qual2, &result);
+}
+
+static ENode *CExpr_DerivedToBase(ENode *expr, Type *type2, UInt32 qual2, Boolean flag1, Boolean nullcheckflag, Boolean pathcheckflag) {
+    BClassList *path;
+    short depth;
+    Boolean isambigbase;
+
+    if (
+        IS_TYPE_CLASS(type2) &&
+        IS_TYPE_CLASS(expr->rtype) &&
+        (path = CClass_GetBasePath(TYPE_CLASS(expr->rtype), TYPE_CLASS(type2), &depth, &isambigbase))
+        )
+    {
+        if (isambigbase)
+            CError_Error(CErrorStr188);
+        if (flag1)
+            CClass_CheckPathAccess(path, NULL, ACCESSPUBLIC);
+
+        if (pathcheckflag) {
+            expr = getnodeaddress(expr, 0);
+            expr = makemonadicnode(CExpr_ClassPointerCast(path, expr, nullcheckflag), EINDIRECT);
+            expr->rtype = type2;
+            expr->flags = qual2 & ENODE_FLAG_QUALS;
+        }
+
+        return expr;
+    }
+    else {
+        return NULL;
+    }
+}
+
+static ENode *CExpr_ClassReferenceConversion(ENode *expr, Type *type2, UInt32 qual2, Boolean pathcheckflag) {
+    int refcompat;
+
+    if (CExpr_IsLValue(expr) && IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
+        refcompat = CExpr_IsReferenceCompatible(type2, 0, expr->rtype, 0);
+        if (refcompat > 0) {
+            if (refcompat == 2) {
+                CError_ASSERT(1668, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
+                expr = CExpr_DerivedToBase(expr, type2, qual2, pathcheckflag, 0, 1);
+            }
+            expr->flags = qual2 & ENODE_FLAG_QUALS;
+            return expr;
+        }
+
+        refcompat = CExpr_IsReferenceCompatible(expr->rtype, 0, type2, 0);
+        if (refcompat > 0) {
+            expr = CClass_ClassPointerCast(
+                getnodeaddress(expr, 0),
+                TYPE_CLASS(expr->rtype), TYPE_CLASS(type2),
+                1, 1, pathcheckflag
+                );
+            CError_ASSERT(1680, IS_TYPE_POINTER_ONLY(expr->rtype));
+            expr = makemonadicnode(expr, EINDIRECT);
+            expr->rtype = type2;
+            expr->flags = qual2 & ENODE_FLAG_QUALS;
+            return expr;
+        }
+    }
+
+    if (IS_TYPE_CLASS(expr->rtype)) {
+        if ((expr = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
+            return expr;
+    }
+
+    return NULL;
+}
+
+static ENode *CExpr_BindToReference(ENode *expr, Type *type2, UInt32 qual2) {
+    UInt32 cv;
+    int refcompat;
+    ENode *tmp;
+
+    cv = CParser_GetCVTypeQualifiers(type2, qual2);
+
+    if (CExpr_IsLValue(expr)) {
+        refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
+        if (refcompat > 0) {
+            if (refcompat == 2) {
+                CError_ASSERT(1718, IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype));
+                expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
+            }
+            return getnodeaddress(expr, 0);
+        }
+    } else if (IS_TYPE_CLASS(type2) && IS_TYPE_CLASS(expr->rtype)) {
+        refcompat = CExpr_IsReferenceCompatible(type2, qual2, expr->rtype, ENODE_QUALS(expr));
+        if (refcompat > 0) {
+            if (refcompat == 2)
+                expr = CExpr_DerivedToBase(expr, type2, qual2, 1, 0, 1);
+            return getnodeaddress(expr, 0);
+        }
+    }
+
+    if (IS_TYPE_CLASS(expr->rtype)) {
+        if ((tmp = CExpr_UserConversion(expr, type2, qual2, NULL, 1, 0, 1)))
+            return getnodeaddress(tmp, 0);
+    }
+
+    if (!(cv & Q_CONST))
+        CError_Error(CErrorStr228);
+    if (cv & Q_VOLATILE)
+        CError_Error(CErrorStr259);
+
+    if (expr->rtype != type2)
+        expr = CExpr_Convert(expr, type2, qual2, 0, 1);
+
+    if (!CExpr_IsLValue(expr)) {
+        expr = CExpr_LValue(expr, 0, 0);
+        if (!ENODE_IS(expr, EINDIRECT))
+            expr = get_address_of_temp_copy(expr, 1);
+        else
+            expr = getnodeaddress(expr, 0);
+    } else {
+        expr = getnodeaddress(expr, 0);
+    }
+
+    return expr;
+}
+
+ENode *CExpr_Convert(ENode *expr, Type *type, UInt32 qual, Boolean isExplicit, Boolean flag2) {
+    UInt32 cv;
+    ENode *refExpr;
+    ENode *newExpr;
+    Type *typeCopy;
+    NameSpaceObjectList myList;
+
+    cv = qual & Q_CV;
+
+    if (copts.cpp_extensions && is_typesame(expr->rtype, type) && !ENODE_IS(expr, EOBJLIST)) {
+        expr = CExpr_RewriteConst(expr);
+        expr->rtype = type;
+        expr->flags &= ~ENODE_FLAG_QUALS;
+        expr->flags |= cv;
+        return expr;
+    }
+
+    if (type == TYPE(&stvoid)) {
+        expr = makemonadicnode(expr, ETYPCON);
+        expr->rtype = type;
+        expr->flags = cv;
+        return expr;
+    }
+
+    if (IS_TYPE_REFERENCE(type)) {
+        if (isExplicit) {
+            refExpr = CExpr_ClassReferenceConversion(expr, TPTR_TARGET(type), qual, flag2);
+            if (refExpr)
+                return refExpr;
+
+            expr = getnodeaddress(expr, 0);
+            typeCopy = galloc(sizeof(TypePointer));
+            *TYPE_POINTER(typeCopy) = *TYPE_POINTER(type);
+            TPTR_QUAL(typeCopy) &= ~Q_REFERENCE;
+            expr = CExpr_Convert(expr, typeCopy, qual, 0, flag2);
+            expr = makemonadicnode(expr, EINDIRECT);
+            expr->rtype = TPTR_TARGET(type);
+            expr->flags = cv;
+            return expr;
+        } else {
+            return CExpr_BindToReference(expr, TPTR_TARGET(type), qual);
+        }
+    }
+
+    if (
+        (IS_TYPE_ARRAY(expr->rtype) && !IS_TYPE_ARRAY(type)) ||
+        (IS_TYPE_FUNC(expr->rtype) && !IS_TYPE_FUNC(type))
+        )
+    {
+        expr = pointer_generation(expr);
+    } else {
+        expr = CExpr_RewriteConst(expr);
+    }
+
+    if (ENODE_IS(expr, EOBJLIST)) {
+        if (CExpr_OverloadFuncMatch(expr->data.objlist.list, expr->data.objlist.templargs, type, &refExpr))
+            return refExpr;
+    } else if (ENODE_IS(expr, EOBJREF) && IS_TEMPL_FUNC(expr->data.objref->type)) {
+        myList.next = NULL;
+        myList.object = OBJ_BASE(expr->data.objref);
+        if (CExpr_OverloadFuncMatch(&myList, NULL, type, &refExpr))
+            return refExpr;
+    } else if (IS_TYPE_CLASS(expr->rtype) || IS_TYPE_CLASS(type)) {
+        if (expr->rtype->size == 0)
+            CDecl_CompleteType(expr->rtype);
+
+        if (IS_TYPE_CLASS(type)) {
+            CanAllocObject(type);
+            if (!CClass_CopyConstructor(TYPE_CLASS(type)) || CClass_IsTrivialCopyClass(TYPE_CLASS(type))) {
+                if (expr->rtype == type)
+                    return expr;
+
+                refExpr = CExpr_DerivedToBase(expr, type, qual, flag2, 0, 1);
+                if (refExpr)
+                    return refExpr;
+            }
+        }
+
+        refExpr = CExpr_UserConversion(expr, type, qual, NULL, 1, isExplicit, 0);
+        if (refExpr) {
+            refExpr->flags = cv;
+            return refExpr;
+        }
+    } else if (!isExplicit && is_typesame(expr->rtype, type)) {
+        if (ENODE_IS(expr, EINDIRECT) && ENODE_QUALS(expr) != cv)
+            expr = makemonadicnode(expr, ETYPCON);
+        expr->rtype = type;
+        expr->flags = cv;
+        return expr;
+    } else {
+        if (
+            copts.warn_implicitconv &&
+            !isExplicit &&
+            IS_TYPE_INT_OR_FLOAT(type) &&
+            IS_TYPE_INT_OR_FLOAT(expr->rtype)
+            )
+            CExpr_CheckArithmConversion(expr, type);
+
+        switch (type->type) {
+            case TYPEINT:
+                if (type == TYPE(&stbool)) {
+                    switch (expr->rtype->type) {
+                        case TYPEINT:
+                        case TYPEFLOAT:
+                        case TYPEENUM:
+                        case TYPEMEMBERPOINTER:
+                        case TYPEPOINTER:
+                            return CExpr_ConvertToBool(expr, isExplicit);
+                    }
+                } else {
+                    switch (expr->rtype->type) {
+                        case TYPEENUM:
+                            expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+                        case TYPEINT:
+                        case TYPEFLOAT:
+                        do_int_float_conversion:
+                            if (
+                                ENODE_IS(expr, ETYPCON) &&
+                                expr->rtype->type == type->type &&
+                                expr->rtype->size == type->size &&
+                                is_unsigned(expr->rtype) == is_unsigned(type) &&
+                                ENODE_QUALS(expr) == qual
+                                )
+                            {
+                                expr->rtype = type;
+                                expr->flags |= ENODE_FLAG_80;
+                                return expr;
+                            } else {
+                                refExpr = promote(expr, type);
+                                refExpr->flags = cv;
+                                return refExpr;
+                            }
+                            break;
+                        case TYPEPOINTER:
+                            if (expr->rtype->size > type->size && copts.warn_ptr_int_conv)
+                                CError_Warning(CErrorStr382);
+                            if (ENODE_IS(expr, ETYPCON)) {
+                                ENode *inner = expr->data.monadic;
+                                if (ENODE_IS(inner, EINTCONST)) {
+                                    inner->rtype = type;
+                                    inner->flags = cv;
+                                    inner->data.intval = CExpr_IntConstConvert(type, TYPE(&stunsignedlong), inner->data.intval);
+                                    return inner;
+                                }
+                            }
+                            if (type->size != 4) {
+                                expr = makemonadicnode(expr, ETYPCON);
+                                expr->rtype = TYPE(&stunsignedlong);
+                            }
+                            expr = makemonadicnode(expr, ETYPCON);
+                            expr->rtype = type;
+                            expr->flags = cv;
+                            return expr;
+                    }
+                }
+                break;
+
+            case TYPEFLOAT:
+                switch (expr->rtype->type) {
+                    case TYPEENUM:
+                        expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+                    case TYPEINT:
+                    case TYPEFLOAT:
+                        goto do_int_float_conversion;
+                }
+                break;
+
+            case TYPEENUM:
+                expr = CExpr_Convert(expr, TYPE_ENUM(type)->enumtype, qual, isExplicit, flag2);
+                if (!ENODE_IS(expr, EINTCONST))
+                    expr = makemonadicnode(expr, ETYPCON);
+                expr->rtype = type;
+                expr->flags = cv;
+                return expr;
+
+            case TYPEPOINTER:
+                switch (expr->rtype->type) {
+                    case TYPEENUM:
+                        expr->rtype = TYPE_ENUM(expr->rtype)->enumtype;
+                    case TYPEINT:
+                        if (expr->rtype->size != 4) {
+                            if (!ENODE_IS(expr, EINTCONST))
+                                expr = makemonadicnode(expr, ETYPCON);
+                            expr->rtype = TYPE(&stunsignedlong);
+                        }
+                        expr = makemonadicnode(expr, ETYPCON);
+                        expr->rtype = type;
+                        expr->flags = cv;
+                        return expr;
+
+                    case TYPEPOINTER:
+                        if (IS_TYPE_CLASS(TPTR_TARGET(expr->rtype)) && IS_TYPE_CLASS(TPTR_TARGET(type)))
+                            expr = CExpr_SafeClassPointerCast(expr, TYPE_CLASS(TPTR_TARGET(expr->rtype)), TYPE_CLASS(TPTR_TARGET(type)), 1, flag2);
+                        if (!ENODE_IS(expr, ETYPCON))
+                            expr = makemonadicnode(expr, ETYPCON);
+                        expr->rtype = type;
+                        expr->flags = cv;
+                        return expr;
+                }
+                break;
+
+            case TYPEMEMBERPOINTER:
+                if (!IS_TYPE_MEMBERPOINTER(expr->rtype))
+                    expr = CExpr_MemberPointerConversion(expr, TYPE_MEMBER_POINTER(type), 1);
+
+                if (IS_TYPE_MEMBERPOINTER(expr->rtype)) {
+                    expr = PointerToMemberCast(expr, TYPE_MEMBER_POINTER(expr->rtype), TYPE_MEMBER_POINTER(type), flag2);
+                    expr->flags = cv;
+                    return expr;
+                }
+                break;
+        }
+    }
+
+    if (isExplicit) {
+        if ((newExpr = CodeGen_HandleTypeCast(expr, type, qual)))
+            return newExpr;
+    }
+
+    CError_Error(
+        isExplicit ? CErrorStr247 : CErrorStr209,
+        expr->rtype, ENODE_QUALS(expr),
+        type, qual);
+    return nullnode();
+}
+
+ENode *CExpr_AssignmentPromotion(ENode *expr, Type *type2, UInt32 qual2, Boolean flag) {
+    ImplicitConv result;
+
+    if (copts.old_argmatch)
+        return oldassignmentpromotion(expr, type2, qual2, flag);
+
+    if (ENODE_IS(expr, EMEMBER))
+        expr = getpointertomemberfunc(expr, type2, 1);
+
+    if (!CExpr_ImplicitConversionMatch(expr, type2, qual2, &result)) {
+        CError_Error(CErrorStr209, expr->rtype, ENODE_QUALS(expr), type2, qual2);
+        return nullnode();
+    }
+
+    return CExpr_Convert(expr, type2, qual2, 0, flag);
+}
+
+static Boolean CExpr_IsBetterMatch(Match *a, Match *b, int count) {
+    ImplicitConv *convA;
+    ImplicitConv *convB;
+    int i;
+    Boolean flag;
+
+    convA = a->conv;
+    convB = b->conv;
+    flag = 0;
+
+    if (convA->type != ICT_0 && convB->type != ICT_0) {
+        if (CExpr_IsBetterImplicitConv(convB, convA))
+            return 0;
+        if (CExpr_IsBetterImplicitConv(convA, convB))
+            flag = 1;
+    }
+
+    for (i = 0; i < count; i++) {
+        if (CExpr_IsBetterImplicitConv(++convB, ++convA))
+            return 0;
+        if (CExpr_IsBetterImplicitConv(convA, convB))
+            flag = 1;
+    }
+
+    if (flag)
+        return 1;
+
+    if (b->object) {
+        CError_ASSERT(2165, IS_TYPE_FUNC(b->object->type));
+        if (b->object->u.func.inst) {
+            if (!a->object)
+                return 1;
+
+            CError_ASSERT(2169, IS_TYPE_FUNC(a->object->type));
+            if (!a->object->u.func.inst)
+                return 1;
+
+            CError_ASSERT(2174, a->specialfunc && b->specialfunc);
+            if (CTempl_FuncIsMoreSpecialized(a->specialfunc, b->specialfunc))
+                return 1;
+        }
+    }
+
+    return 0;
+}
+
+static Boolean CExpr_MatchArgs(Object *func, ENodeList *argexprs, ENode *expr, ImplicitConv *convs) {
+    FuncArg *args;
+    ENode *newExpr;
+    Type *type;
+
+    args = TYPE_FUNC(func->type)->args;
+
+    if (!(TYPE_FUNC(func->type)->flags & FUNC_FLAGS_METHOD)) {
+        convs->type = ICT_0;
+    } else if (TYPE_METHOD(func->type)->x26) {
+        convs->type = ICT_0;
+    } else if (TYPE_FUNC(func->type)->flags & FUNC_FLAGS_1000) {
+        convs->type = ICT_0;
+        args = args->next;
+    } else {
+        if (!expr)
+            return 0;
+
+        newExpr = lalloc(sizeof(ENode));
+        newExpr->type = EINTCONST;
+        newExpr->cost = 0;
+        newExpr->flags = expr->flags;
+        newExpr->rtype = CDecl_NewPointerType(expr->rtype);
+        newExpr->data.intval = cint64_zero;
+
+        if (func->datatype == DALIAS) {
+            CError_ASSERT(2231, func->u.alias.member);
+            type = CDecl_NewPointerType(func->u.alias.member->type);
+        } else {
+            type = args->type;
+        }
+
+        if (!CExpr_ImplicitConversionMatch(newExpr, type, args->qual, convs))
+            return 0;
+        args = args->next;
+    }
+
+    convs++;
+    while (1) {
+        if (!args || args->type == &stvoid) {
+            if (argexprs)
+                return 0;
+            else
+                return 1;
+        }
+
+        if (args == &elipsis || args == &oldstyle) {
+            while (argexprs) {
+                convs->type = ICT_1;
+                argexprs = argexprs->next;
+                convs++;
+            }
+            return 1;
+        }
+
+        if (!argexprs)
+            return args->dexpr != NULL;
+
+        if (!CExpr_ImplicitConversionMatch(argexprs->node, args->type, args->qual, convs))
+            return 0;
+
+        argexprs = argexprs->next;
+        args = args->next;
+        convs++;
+    }
+}
+
+static Object *CExpr_GetMatchObject(Match *match, HashNameNode *name) {
+    Object *object;
+    FuncArg *arg;
+    TypeFunc *tfunc;
+
+    if (match->object)
+        return match->object;
+
+    tfunc = lalloc(sizeof(TypeFunc));
+    memclrw(tfunc, sizeof(TypeFunc));
+    tfunc->type = TYPEFUNC;
+    tfunc->functype = &stvoid;
+
+    arg = lalloc(sizeof(FuncArg));
+    memclrw(arg, sizeof(FuncArg));
+    arg->type = match->type;
+    arg->qual = match->qual;
+    tfunc->args = arg;
+
+    if (match->type2) {
+        arg = lalloc(sizeof(FuncArg));
+        memclrw(arg, sizeof(FuncArg));
+        arg->type = match->type2;
+        arg->qual = match->qual2;
+        tfunc->args->next = arg;
+    }
+
+    object = lalloc(sizeof(Object));
+    memclrw(object, sizeof(Object));
+    object->name = name;
+    object->datatype = DFUNC;
+    object->nspace = cscope_root;
+    object->type = TYPE(tfunc);
+    return object;
+}
+
+static Match *CExpr_FindBestMatch(Match *matches, int count, HashNameNode *name, ObjectList **outList, ENodeList *argExprs) {
+    Match *scan;
+    Match *best;
+    ObjectList *listHead;
+    ObjectList *list;
+
+    best = matches;
+    for (scan = matches->next; scan; scan = scan->next) {
+        if (CExpr_IsBetterMatch(scan, best, count))
+            best = scan;
+    }
+
+    for (scan = matches, listHead = NULL; scan; scan = scan->next) {
+        if (scan != best && !CExpr_IsBetterMatch(best, scan, count)) {
+            list = lalloc(sizeof(ObjectList));
+            list->next = listHead;
+            list->object = CExpr_GetMatchObject(scan, name);
+            listHead = list;
+        }
+    }
+
+    if (!outList) {
+        if (listHead)
+            CError_OverloadedFunctionError(CExpr_GetMatchObject(best, name), listHead);
+    } else {
+        *outList = listHead;
+    }
+
+    return best;
+}
+
+void CExpr_FuncArgMatch(NameSpaceObjectList *list, TemplArg *templargs, ENodeList *argexprs, Match13 *match13, ENode *expr, Boolean flag) {
+    NameSpaceObjectList *i;
+    NameSpaceObjectList *j;
+    Match *match;
+    Match *matches;
+    Object *object;
+    Object *object2;
+    Object *specialfunc;
+    ENodeList *argscan;
+    int argcount;
+
+    for (argscan = argexprs, argcount = 0; argscan; argscan = argscan->next) {
+        CDecl_CompleteType(argscan->node->rtype);
+        argcount++;
+    }
+
+    matches = NULL;
+    match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
+
+    for (i = list; i; i = i->next) {
+        object = OBJECT(i->object);
+        if (
+            object->otype == OT_OBJECT &&
+            IS_TYPE_FUNC(object->type) &&
+            (!flag || !(object->qual & Q_EXPLICIT))
+            )
+        {
+            if (object->datatype == DALIAS && (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD)) {
+                for (j = list; j; j = j->next) {
+                    if (j == i)
+                        continue;
+
+                    object2 = OBJECT(j->object);
+                    if (
+                        object2->otype == OT_OBJECT &&
+                        IS_TYPE_METHOD(object2->type) &&
+                        (TYPE_FUNC(object2->type)->flags & FUNC_FLAGS_CV) == (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_CV)
+                        )
+                    {
+                        FuncArg *argsA;
+                        FuncArg *argsB;
+                        argsA = TYPE_FUNC(object->type)->args;
+                        if (argsA && !TYPE_METHOD(object->type)->x26)
+                            argsA = argsA->next;
+                        argsB = TYPE_FUNC(object2->type)->args;
+                        if (argsB && !TYPE_METHOD(object2->type)->x26)
+                            argsB = argsB->next;
+                        if (is_arglistsame(argsA, argsB))
+                            break;
+                    }
+                }
+
+                if (j)
+                    continue;
+            }
+
+            if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+                specialfunc = object;
+                object = CTempl_DeduceFromFunctionCall(object, templargs, argexprs);
+                if (!object)
+                    continue;
+            } else {
+                if (templargs)
+                    continue;
+                specialfunc = NULL;
+            }
+
+            if (CExpr_MatchArgs(object, argexprs, expr, match->conv)) {
+                match->object = object;
+                match->specialfunc = specialfunc;
+                match->next = matches;
+                matches = match;
+                match = lalloc(sizeof(Match) + ((argcount - 2) * sizeof(ImplicitConv)));
+            }
+        }
+    }
+
+    if (matches) {
+        matches = CExpr_FindBestMatch(matches, argcount, NULL, &match13->list, argexprs);
+        match13->obj = matches->object;
+    }
+}
+
+static ConversionTypeList *CExpr_BuildConversionTypeList(ENode *expr) {
+    ConversionTypeList *first;
+    ConversionTypeList *list;
+    Object *object;
+    Type *type;
+    ConversionIterator convIter;
+
+    if (!IS_TYPE_CLASS(expr->rtype)) {
+        first = lalloc(sizeof(ConversionTypeList));
+        first->next = NULL;
+        first->func = NULL;
+        first->type = expr->rtype;
+        first->qual = ENODE_QUALS(expr);
+        if (IS_TYPE_ENUM(first->type))
+            first->qual = 0;
+    } else {
+        first = NULL;
+        CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr->rtype));
+        while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+            type = TYPE_FUNC(object->type)->functype;
+            if (IS_TYPE_REFERENCE(type))
+                type = TPTR_TARGET(type);
+
+            if (!IS_TYPE_CLASS(type)) {
+                list = lalloc(sizeof(ConversionTypeList));
+                list->next = first;
+                list->func = object;
+                list->type = type;
+                list->qual = TYPE_FUNC(object->type)->qual & Q_CV;
+                first = list;
+            }
+        }
+    }
+
+    return first;
+}
+
+static Type *CExpr_NextPromotedIntegralType(int *p) {
+    switch (++(*p)) {
+        case 1: return TYPE(&stsignedint);
+        case 2: return TYPE(&stunsignedint);
+        case 3: return TYPE(&stsignedlong);
+        case 4: return TYPE(&stunsignedlong);
+        case 5:
+            if (copts.longlong)
+                return TYPE(&stsignedlonglong);
+            else
+                return NULL;
+        case 6:
+            if (copts.longlong)
+                return TYPE(&stunsignedlonglong);
+            else
+                return NULL;
+    }
+
+    return NULL;
+}
+
+static Type *CExpr_NextArithmeticType(int *p) {
+    switch (++(*p)) {
+        case 1: return TYPE(&stbool);
+        case 2: return TYPE(&stchar);
+        case 3: return TYPE(&stsignedchar);
+        case 4: return TYPE(&stunsignedchar);
+        case 5: return TYPE(&stwchar);
+        case 6: return TYPE(&stsignedshort);
+        case 7: return TYPE(&stunsignedshort);
+        case 8: return TYPE(&stsignedint);
+        case 9: return TYPE(&stunsignedint);
+        case 10: return TYPE(&stsignedlong);
+        case 11: return TYPE(&stunsignedlong);
+        case 12: return TYPE(&stfloat);
+        case 13: return TYPE(&stdouble);
+        case 14: return TYPE(&stlongdouble);
+        case 15:
+            if (copts.longlong)
+                return TYPE(&stsignedlonglong);
+            else
+                return NULL;
+        case 16:
+            if (copts.longlong)
+                return TYPE(&stunsignedlonglong);
+            else
+                return NULL;
+    }
+
+    return NULL;
+}
+
+static Type *CExpr_NextPromotedArithmeticType(int *p) {
+    switch (++(*p)) {
+        case 1: return TYPE(&stsignedint);
+        case 2: return TYPE(&stunsignedint);
+        case 3: return TYPE(&stsignedlong);
+        case 4: return TYPE(&stunsignedlong);
+        case 5: return TYPE(&stdouble);
+        case 6: return TYPE(&stlongdouble);
+        case 7:
+            if (copts.longlong)
+                return TYPE(&stsignedlonglong);
+            else
+                return NULL;
+        case 8:
+            if (copts.longlong)
+                return TYPE(&stunsignedlonglong);
+            else
+                return NULL;
+    }
+
+    return NULL;
+}
+
+static Match *CExpr_MatchBuiltin(Match *matches, ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual) {
+    Match *scan;
+    Match mymatch;
+
+    if (CExpr_ImplicitConversionMatch(left, leftType, leftQual, &mymatch.conv[0])) {
+        if (!right || CExpr_ImplicitConversionMatch(right, rightType, rightQual, &mymatch.conv[1])) {
+            if (right) {
+                for (scan = matches; scan; scan = scan->next) {
+                    if (
+                        !scan->object &&
+                        is_typesame(scan->type, leftType) &&
+                        scan->qual == leftQual &&
+                        is_typesame(scan->type2, rightType) &&
+                        scan->qual2 == rightQual
+                    )
+                        return matches;
+                }
+            }
+
+            mymatch.next = matches;
+            mymatch.object = NULL;
+            mymatch.specialfunc = NULL;
+            mymatch.type = leftType;
+            mymatch.qual = leftQual;
+            mymatch.type2 = rightType;
+            mymatch.qual2 = rightQual;
+
+            matches = lalloc(sizeof(Match));
+            *matches = mymatch;
+        }
+    }
+
+    return matches;
+}
+
+static Match *CExpr_CheckIncDecBuiltin(Match *matches, short token, ENode *expr1, ENode *expr2) {
+    Object *object;
+    Type *type;
+    TypeFunc *tfunc;
+    ConversionIterator convIter;
+
+    if (IS_TYPE_CLASS(expr1->rtype)) {
+        CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr1->rtype));
+        while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+            tfunc = TYPE_FUNC(object->type);
+            if (IS_TYPE_REFERENCE(tfunc->functype)) {
+                type = TPTR_TARGET(tfunc->functype);
+                switch (type->type) {
+                    case TYPEINT:
+                        if (type == TYPE(&stbool) && token == TK_DECREMENT)
+                            break;
+                    case TYPEFLOAT:
+                    case TYPEPOINTER:
+                        if (!CParser_IsConst(type, tfunc->qual)) {
+                            matches = CExpr_MatchBuiltin(
+                                matches,
+                                expr1, type, tfunc->qual,
+                                expr2, expr2 ? TYPE(&stsignedint) : NULL, 0
+                                );
+                        }
+                        break;
+                }
+            }
+        }
+    }
+
+    return matches;
+}
+
+static Match *CExpr_CheckUnaryBuiltin(Match *matches, short token, ENode *expr) {
+    ConversionTypeList *typelist;
+    Type *type;
+    int typenum;
+
+    switch (token) {
+        case TK_INCREMENT:
+        case TK_DECREMENT:
+            return CExpr_CheckIncDecBuiltin(matches, token, expr, NULL);
+
+        case '!':
+            matches = CExpr_MatchBuiltin(matches, expr, TYPE(&stbool), 0, NULL, NULL, 0);
+            break;
+
+        case '~':
+            typenum = 0;
+            while ((type = CExpr_NextPromotedIntegralType(&typenum))) {
+                matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
+            }
+            break;
+
+        case '*':
+        case '+':
+            for (typelist = CExpr_BuildConversionTypeList(expr); typelist; typelist = typelist->next) {
+                if (IS_TYPE_POINTER_ONLY(typelist->type))
+                    matches = CExpr_MatchBuiltin(matches, expr, typelist->type, typelist->qual, NULL, NULL, 0);
+            }
+            if (token != '+')
+                break;
+
+        case '-':
+            typenum = 0;
+            while ((type = CExpr_NextPromotedArithmeticType(&typenum))) {
+                matches = CExpr_MatchBuiltin(matches, expr, type, 0, NULL, NULL, 0);
+            }
+            break;
+    }
+
+    return matches;
+}
+
+static Match *CExpr_CheckBinaryBuiltin(Match *matches, ENode *left, short token, ENode *right) {
+    int typenum1;
+    int typenum2;
+    Type *type1;
+    Type *type2;
+    Type *ptrdiff;
+    Boolean allowPtrDiffOnRight;
+    Boolean allowPtrCV;
+    Boolean allowPtrDiffOnLeft;
+    Boolean allowMemberPtrs;
+    Boolean allowEnum;
+    ConversionTypeList *leftList;
+    ConversionTypeList *rightList;
+    ConversionTypeList *scan;
+
+    switch (token) {
+        case TK_INCREMENT:
+        case TK_DECREMENT:
+            return CExpr_CheckIncDecBuiltin(matches, token, left, right);
+
+        case '*':
+        case '+':
+        case '-':
+        case '/':
+        case ':':
+        case '<':
+        case '>':
+        case TK_LOGICAL_EQ:
+        case TK_LOGICAL_NE:
+        case TK_LESS_EQUAL:
+        case TK_GREATER_EQUAL:
+            typenum1 = 0;
+            while ((type1 = CExpr_NextPromotedArithmeticType(&typenum1))) {
+                typenum2 = 0;
+                while ((type2 = CExpr_NextPromotedArithmeticType(&typenum2))) {
+                    matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
+                }
+            }
+            break;
+
+        case '%':
+        case '&':
+        case '^':
+        case '|':
+        case TK_SHL:
+        case TK_SHR:
+            typenum1 = 0;
+            while ((type1 = CExpr_NextPromotedIntegralType(&typenum1))) {
+                typenum2 = 0;
+                while ((type2 = CExpr_NextPromotedIntegralType(&typenum2))) {
+                    matches = CExpr_MatchBuiltin(matches, left, type1, 0, right, type2, 0);
+                }
+            }
+            return matches;
+
+        case TK_LOGICAL_OR:
+        case TK_LOGICAL_AND:
+            return CExpr_MatchBuiltin(matches, left, TYPE(&stbool), 0, right, TYPE(&stbool), 0);
+    }
+
+    allowEnum = 0;
+    allowMemberPtrs = 0;
+    allowPtrCV = 0;
+    allowPtrDiffOnLeft = 0;
+    allowPtrDiffOnRight = 0;
+
+    switch (token) {
+        case '+':
+        case '[':
+            allowPtrDiffOnLeft = 1;
+            allowPtrDiffOnRight = 1;
+            break;
+        case '-':
+            allowPtrCV = 1;
+            allowPtrDiffOnRight = 1;
+            break;
+        case ':':
+        case TK_LOGICAL_EQ:
+        case TK_LOGICAL_NE:
+            allowMemberPtrs = 1;
+        case '<':
+        case '>':
+        case TK_LESS_EQUAL:
+        case TK_GREATER_EQUAL:
+            allowPtrCV = 1;
+            allowEnum = 1;
+            break;
+        default:
+            return matches;
+    }
+
+    leftList = CExpr_BuildConversionTypeList(left);
+    rightList = CExpr_BuildConversionTypeList(right);
+    ptrdiff = CABI_GetPtrDiffTType();
+
+    for (scan = leftList; ; scan = scan->next) {
+        if (!scan) {
+            scan = rightList;
+            if (!rightList)
+                break;
+            rightList = NULL;
+        }
+
+        type1 = scan->type;
+        if (IS_TYPE_REFERENCE(type1))
+            type1 = TPTR_TARGET(type1);
+
+        switch (type1->type) {
+            case TYPEENUM:
+                if (allowEnum)
+                    matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
+                break;
+
+            case TYPEPOINTER:
+                if (allowPtrDiffOnRight)
+                    matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, ptrdiff, 0);
+                if (allowPtrDiffOnLeft)
+                    matches = CExpr_MatchBuiltin(matches, left, ptrdiff, 0, right, type1, scan->qual);
+                if (allowPtrCV) {
+                    if (IS_TYPE_POINTER_ONLY(TPTR_TARGET(type1))) {
+                        type2 = galloc(sizeof(TypePointer));
+                        *TYPE_POINTER(type2) = *TYPE_POINTER(type1);
+                        TPTR_QUAL(type2) |= Q_CONST | Q_VOLATILE;
+                        matches = CExpr_MatchBuiltin(matches, left, type2, scan->qual, right, type2, scan->qual);
+                    } else {
+                        matches = CExpr_MatchBuiltin(matches, left, type1, Q_CONST | Q_VOLATILE, right, type1, Q_CONST | Q_VOLATILE);
+                    }
+                }
+                break;
+
+            case TYPEMEMBERPOINTER:
+                if (allowMemberPtrs)
+                    matches = CExpr_MatchBuiltin(matches, left, type1, scan->qual, right, type1, scan->qual);
+                break;
+        }
+    }
+
+    return matches;
+}
+
+static Boolean CExpr_MatchOperands(ENode *left, Type *leftType, UInt32 leftQual, ENode *right, Type *rightType, UInt32 rightQual, ImplicitConv *twoResults, Boolean flag) {
+    if (flag) {
+        if (!CExpr_StandardConversionMatch(left, leftType, leftQual, 1, &twoResults[0].u.ic3.standardConv))
+            return 0;
+        twoResults[0].type = ICT_3;
+    } else {
+        if (!CExpr_ImplicitConversionMatch(left, leftType, leftQual, &twoResults[0]))
+            return 0;
+    }
+
+    if (right) {
+        if (!CExpr_ImplicitConversionMatch(right, rightType, rightQual, &twoResults[1]))
+            return 0;
+    }
+
+    return 1;
+}
+
+Boolean CExpr_CondOperatorMatch(ENode *left, ENode *right, Conversion *conv) {
+    Match *match;
+
+    if ((match = CExpr_CheckBinaryBuiltin(NULL, left, ':', right))) {
+        match = CExpr_FindBestMatch(match, 1, GetHashNameNode("operator?:"), NULL, NULL);
+        CError_ASSERT(2931, !match->object);
+
+        conv->x0 = NULL;
+        conv->left = CExpr_Convert(left, match->type, match->qual, 0, 1);
+        conv->right = CExpr_Convert(right, match->type2, match->qual2, 0, 1);
+        return 1;
+    }
+
+    return 0;
+}
+
+Boolean CExpr_OperatorMatch(short token, ENode *left, ENode *right, Conversion *conv) {
+    HashNameNode *name;
+    ENodeList *argExprs;
+    BClassList *path;
+    int hasArg;
+    Match *matches;
+    Object *object;
+    Object *specialfunc;
+    NameSpaceObjectList *list;
+    Type *leftType;
+    UInt32 leftQual;
+    Type *rightType;
+    UInt32 rightQual;
+    CScopeParseResult pr;
+    NameSpaceObjectList myList;
+    Match myMatch;
+
+    if (!IS_TYPE_CLASS(left->rtype)) {
+        if (!IS_TYPE_ENUM(left->rtype)) {
+            if (!right || !(IS_TYPE_CLASS(right->rtype) || IS_TYPE_ENUM(right->rtype)))
+                return 0;
+        }
+    } else {
+        CDecl_CompleteType(left->rtype);
+    }
+
+    name = CMangler_OperatorName(token);
+    path = NULL;
+
+    argExprs = lalloc(sizeof(ENodeList));
+    argExprs->node = left;
+    if (right) {
+        argExprs->next = lalloc(sizeof(ENodeList));
+        argExprs->next->node = right;
+        argExprs->next->next = NULL;
+        hasArg = 1;
+    } else {
+        argExprs->next = NULL;
+        hasArg = 0;
+    }
+
+    matches = NULL;
+
+    if (IS_TYPE_CLASS(left->rtype) && CScope_FindClassMemberObject(TYPE_CLASS(left->rtype), &pr, name)) {
+        if (token != '=' || (pr.bcl_18->type == left->rtype && !pr.bcl_18->next)) {
+            if (pr.obj_10) {
+                myList.next = NULL;
+                myList.object = pr.obj_10;
+                pr.nsol_14 = &myList;
+            } else {
+                CError_ASSERT(3009, pr.nsol_14);
+            }
+
+            for (list = pr.nsol_14; list; list = list->next) {
+                object = OBJECT(list->object);
+                if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type)) {
+                    if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+                        specialfunc = object;
+                        object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs->next);
+                        if (!object)
+                            continue;
+                    } else {
+                        specialfunc = NULL;
+                    }
+
+                    leftType = CExpr_GetImplictObjectParamType(object, &leftQual);
+                    if (right) {
+                        if (!CExpr_HasNParams(object, 1))
+                            continue;
+                        rightType = CExpr_GetParamType(object, 0, &rightQual);
+                    } else {
+                        if (!CExpr_HasNParams(object, 0))
+                            continue;
+                    }
+
+                    if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 1)) {
+                        myMatch.object = object;
+                        myMatch.specialfunc = specialfunc;
+                        myMatch.next = matches;
+                        matches = lalloc(sizeof(Match));
+                        *matches = myMatch;
+                        path = pr.bcl_18;
+                    }
+                }
+            }
+        }
+    }
+
+    if (CScope_FindNonClassObject(cscope_current, &pr, name)) {
+        if (pr.obj_10) {
+            myList.next = NULL;
+            myList.object = pr.obj_10;
+            pr.nsol_14 = &myList;
+        }
+    } else {
+        pr.nsol_14 = NULL;
+    }
+
+    if (copts.arg_dep_lookup)
+        pr.nsol_14 = CScope_ArgumentDependentNameLookup(pr.nsol_14, name, argExprs, 1);
+
+    for (list = pr.nsol_14; list; list = list->next) {
+        object = OBJECT(list->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_NONMETHOD(object->type)) {
+            if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000) {
+                specialfunc = object;
+                object = CTempl_DeduceFromFunctionCall(object, NULL, argExprs);
+                if (!object)
+                    continue;
+            } else {
+                specialfunc = NULL;
+            }
+
+            leftType = CExpr_GetParamType(object, 0, &leftQual);
+            if (right) {
+                if (!CExpr_HasNParams(object, 2))
+                    continue;
+                rightType = CExpr_GetParamType(object, 1, &rightQual);
+            } else {
+                if (!CExpr_HasNParams(object, 1))
+                    continue;
+            }
+
+            if (CExpr_MatchOperands(left, leftType, leftQual, right, rightType, rightQual, myMatch.conv, 0)) {
+                myMatch.object = object;
+                myMatch.specialfunc = specialfunc;
+                myMatch.next = matches;
+                matches = lalloc(sizeof(Match));
+                *matches = myMatch;
+            }
+        }
+    }
+
+    if (right)
+        matches = CExpr_CheckBinaryBuiltin(matches, left, token, right);
+    else
+        matches = CExpr_CheckUnaryBuiltin(matches, token, left);
+
+    if (matches) {
+        conv->x0 = NULL;
+        conv->left = NULL;
+        conv->right = NULL;
+
+        matches = CExpr_FindBestMatch(matches, hasArg, name, NULL, argExprs);
+        object = matches->object;
+        if (!object) {
+            if (IS_TYPE_CLASS(left->rtype))
+                conv->left = CExpr_Convert(left, matches->type, matches->qual, 0, 1);
+            else
+                conv->left = left;
+
+            if (right) {
+                if (IS_TYPE_CLASS(right->rtype))
+                    conv->right = CExpr_Convert(right, matches->type2, matches->qual2, 0, 1);
+                else
+                    conv->right = right;
+            }
+
+            return 1;
+        }
+
+        if (IS_TYPEFUNC_NONSTATIC_METHOD(TYPE_FUNC(object->type))) {
+            CError_ASSERT(3125, path);
+            left = CExpr_GenericFuncCall(path, argExprs->node, 0, object, NULL, NULL, argExprs->next, 0, 0, 1);
+        } else {
+            left = CExpr_GenericFuncCall(NULL, NULL, 0, object, NULL, NULL, argExprs, 0, 0, 1);
+        }
+
+        conv->x0 = checkreference(left);
+        return 1;
+    }
+
+    return 0;
+}
+
+static ENode *CExpr_ClassCopyInit(TypeClass *tclass, ENode *expr1, ENode *expr2) {
+    Object *best;
+    NameSpaceObjectList *list;
+    ObjectList *objlist;
+    ObjectList *objlistEntry;
+    ENodeList *argExprs;
+    FuncArg *arg;
+    Type *type;
+    Object *object;
+    ImplicitConv bestConv;
+    ImplicitConv conv;
+    BClassList path;
+    ConversionIterator convIter;
+
+    best = NULL;
+    objlist = NULL;
+
+    for (list = CClass_Constructor(tclass); list; list = list->next) {
+        object = OBJECT(list->object);
+        if (object->otype == OT_OBJECT && IS_TYPE_FUNC(object->type) && !(object->qual & Q_EXPLICIT)) {
+            arg = TYPE_FUNC(object->type)->args;
+
+            CError_ASSERT(3199, arg);
+            arg = arg->next;
+
+            if (tclass->flags & CLASS_FLAGS_20) {
+                CError_ASSERT(3203, arg);
+                arg = arg->next;
+            }
+
+            if (
+                arg &&
+                arg != &elipsis &&
+                (!arg->next || arg->next->dexpr) &&
+                CExpr_ImplicitConversionMatch(expr2, arg->type, arg->qual, &conv)
+                )
+            {
+                if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
+                    best = object;
+                    bestConv = conv;
+                    objlist = NULL;
+                } else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
+                    objlistEntry = lalloc(sizeof(ObjectList));
+                    objlistEntry->next = objlist;
+                    objlistEntry->object = object;
+                    objlist = objlistEntry;
+                }
+            }
+        }
+    }
+
+    if (IS_TYPE_CLASS(expr2->rtype)) {
+        CExpr_ConversionIteratorInit(&convIter, TYPE_CLASS(expr2->rtype));
+        while ((object = CExpr_ConversionIteratorNext(&convIter))) {
+            type = TYPE_FUNC(object->type)->functype;
+            if (IS_TYPE_REFERENCE(type))
+                type = TPTR_TARGET(type);
+
+            if (
+                IS_TYPE_CLASS(type) &&
+                (tclass == TYPE_CLASS(type) || CClass_IsBaseClass(tclass, TYPE_CLASS(type), NULL, 0, 0))
+                )
+            {
+                CError_ASSERT(3248, TYPE_FUNC(object->type)->args &&
+                                    IS_TYPE_POINTER_ONLY(TYPE_FUNC(object->type)->args->type));
+
+                type = galloc(sizeof(TypePointer));
+                *TYPE_POINTER(type) = *TYPE_POINTER(TYPE_FUNC(object->type)->args->type);
+                TPTR_QUAL(type) = Q_REFERENCE;
+                if (CExpr_ImplicitConversionMatch(expr2, type, TYPE_FUNC(object->type)->args->qual, &conv)) {
+                    if (!best || CExpr_IsBetterImplicitConv(&conv, &bestConv)) {
+                        best = object;
+                        bestConv = conv;
+                        objlist = NULL;
+                    } else if (!CExpr_IsBetterImplicitConv(&bestConv, &conv)) {
+                        objlistEntry = lalloc(sizeof(ObjectList));
+                        objlistEntry->next = objlist;
+                        objlistEntry->object = object;
+                        objlist = objlistEntry;
+                    }
+                }
+            }
+        }
+    }
+
+    if (objlist)
+        CError_OverloadedFunctionError(best, objlist);
+
+    if (!best) {
+        CError_Error(CErrorStr209, expr2->rtype, ENODE_QUALS(expr2), tclass, 0);
+        return expr1;
+    }
+
+    CError_ASSERT(3284, IS_TYPE_POINTER_ONLY(expr1->rtype));
+
+    expr1 = makemonadicnode(expr1, EINDIRECT);
+    expr1->rtype = TYPE(tclass);
+
+    argExprs = lalloc(sizeof(ENodeList));
+    argExprs->node = expr2;
+    if (tclass->flags & CLASS_FLAGS_20) {
+        argExprs->next = lalloc(sizeof(ENodeList));
+        argExprs->next->next = NULL;
+        argExprs->next->node = intconstnode(TYPE(&stsignedshort), 1);
+    } else {
+        argExprs->next = NULL;
+    }
+
+    path.next = NULL;
+    path.type = TYPE(tclass);
+    expr1 = CExpr_GenericFuncCall(&path, expr1, 0, best, NULL, NULL, argExprs, 0, 0, 1);
+
+    if (ENODE_IS2(expr1, EFUNCCALL, EFUNCCALLP))
+        expr1->rtype = CDecl_NewPointerType(TYPE(tclass));
+
+    expr1 = makemonadicnode(expr1, EINDIRECT);
+    expr1->rtype = TYPE(tclass);
+    return expr1;
+}
diff --git a/compiler_and_linker/unsorted/CFunc.c b/compiler_and_linker/unsorted/CFunc.c
index 780dbd2..94a2c9e 100644
--- a/compiler_and_linker/unsorted/CFunc.c
+++ b/compiler_and_linker/unsorted/CFunc.c
@@ -1,6 +1,73 @@
 #include "compiler/CFunc.h"
+#include "compiler/CABI.h"
+#include "compiler/CClass.h"
+#include "compiler/CDecl.h"
+#include "compiler/CError.h"
+#include "compiler/CException.h"
+#include "compiler/CExpr.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
+#include "compiler/CInt64.h"
+#include "compiler/CMachine.h"
+#include "compiler/CMangler.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateTools.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
+#include "compiler/FuncLevelAsmPPC.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/ObjGenMachO.h"
+#include "compiler/Switch.h"
+#include "compiler/objects.h"
+#include "compiler/scopes.h"
 #include "compiler/types.h"
 
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+struct CFuncSave {
+    CScopeSave scope;
+    ObjectList *arguments;
+    ObjectList *locals;
+    CLabel *labels;
+    Statement *curstmt;
+    DeclBlock *firstblock;
+    DeclBlock *currentblock;
+    ExceptionAction *cexcept_dobjstack;
+    CLabel *sinit_label;
+    ENode *ainit_expr;
+    CtorChain *ctor_chain;
+    ParserTryBlock *trychain;
+    TempNodeCB cinit_tempnodefunc;
+    HashNameNode *tkidentifier;
+    Object *sinit_first_object;
+    FileOffsetInfo cparser_fileoffset;
+    TStreamElement symdecltoken;
+    SInt32 functionbodyoffset;
+    HashNameNode *functionbodypath;
+    SInt32 symdecloffset;
+    SInt32 symdeclend;
+    SInt32 sourceoffset;
+    HashNameNode *sourcefilepath;
+    SInt32 curstmtvalue;
+    NameObjCheckCB name_obj_check;
+    FuncArg *check_arglist;
+    short blockcount;
+    short localcount;
+    short tk;
+    AccessType global_access;
+    Boolean cexcept_hasdobjects;
+    Boolean ainit_only_one;
+    Boolean cfunc_is_extern_c;
+    Boolean temp_reference_init;
+};
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
+
 FuncArg elipsis;
 FuncArg oldstyle;
 ObjectList *arguments;
@@ -31,75 +98,3127 @@ static short cfunc_staticvarcount;
 static void *destroyobjects;
 static Boolean cfunc_hasdtortemp;
 
-static void CFunc_LoopIncrement(void) {}
-static void CFunc_LoopDecrement(void) {}
-DeclBlock *CFunc_NewDeclBlock(void) {}
-void CFunc_RestoreBlock(DeclBlock *block) {}
-void CFunc_SetupLocalVarInfo(Object *obj) {}
-static void adjustargumenttype(DeclInfo *declinfo) {}
-static FuncArg *CFunc_IsInArgList(FuncArg *list, HashNameNode *name) {}
-static Object *CFunc_IsInObjList(ObjectList *list, HashNameNode *name) {}
-static void CFunc_AppendArg(FuncArg **list, FuncArg *arg) {}
-static void identifier_list(DeclInfo *declinfo) {}
-static Boolean defarg_name_obj_check(HashNameNode *name, Object *obj) {}
-void CFunc_DefaultArg(Type *type, short qual, FuncArg *args) {}
-static FuncArg *parameter_list(DeclInfo *declinfo) {}
-Boolean CFunc_ParseFakeArgList(Boolean flag) {}
-FuncArg *parameter_type_list(DeclInfo *declinfo) {}
-CLabel *findlabel(void) {}
-CLabel *newlabel(void) {}
-Statement *CFunc_AppendStatement(StatementType sttype) {}
-Statement *CFunc_InsertStatement(StatementType sttype, Statement *after) {}
-Statement *CFunc_InsertBeforeStatement(StatementType sttype, Statement *before) {}
-void CheckCLabels(void) {}
-Object *create_temp_object(Type *type) {}
-ENode *create_temp_node(Type *type) {}
-ENode *create_temp_node2(Type *type) {}
-static void CFunc_DestroyReverse() {} // not sure about type
-static void CFunc_TempTransDestroy() {} // not sure about type
-void CFunc_WarnUnused(void) {}
-void CFunc_CodeCleanup(Statement *stmt) {}
-static Boolean DestructorNeeded(ExceptionAction *a, ExceptionAction *b) {}
-static Statement *DestructLocals(Statement *stmt, ExceptionAction *exc1, ExceptionAction *exc2) {}
-static Boolean NeedsDestruction(Statement *stmt1, Statement *stmt2) {}
-static ExceptionAction *FindLastNonCommonStackObj(Statement *stmt1, Statement *stmt2) {}
-static void DestructorReturnTransform(Statement *stmt1, Statement *stmt2) {}
-static Statement *DestructorIfTransform(Statement *stmt) {}
-static Boolean IsSubStack(ExceptionAction *exc1, ExceptionAction *exc2) {}
-static void CFunc_CheckInitSkip(Statement *stmt, ExceptionAction *exc) {}
-void CFunc_DestructorCleanup(Statement *stmt) {}
-static void scancase(DeclThing *thing) {}
-static void CFunc_NameLocalStaticDataObject(Object *obj, char *str) {}
-static void sinit_insert_expr(ENode *expr) {}
-static void ainit_insert_expr(ENode *expr) {}
-static ENode *ainit_register_object(TypeClass *tclass, Object *local, SInt32 offset, void *unk) {}
-static void CFunc_LocalDataDeclarator(DeclInfo *declinfo, TStreamElement *element, Boolean flag1, Boolean flag2) {}
-static ENode *CFunc_ParseLocalDeclarationList(Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4) {}
-static void makeifstatement(ENode *expr, CLabel *label1, CLabel *label2, Boolean flag1, Boolean flag2) {}
-static void CFunc_HasDtorTempCallBack(ENode *expr) {}
-static void ifstatement(Boolean flag1, ENode *expr, CLabel *label, Boolean flag2) {}
-Statement *CFunc_GenerateLoop(Statement *stmt, Type *type, ENode *expr1, ENode *expr2, ENode *expr3, ENode *expr4, ENode (*callback)(ENode *, ENode *)) {}
-static Boolean checklabel(void) {}
-static ENode *returnstatementadjust(ENode *expr, Type *type, UInt32 qual) {}
-static void CFunc_AutoResultCheck(ENode *expr) {}
-static void statement(DeclThing *thing) {}
-void CFunc_CompoundStatement(DeclThing *thing) {}
-static void CFunc_InsertArgumentCopyConversion(Object *obj, Type *type1, Type *type2, Boolean flag) {}
-static void CFunc_AdjustOldStyleArgs(void) {}
-void CFunc_SetupNewFuncArgs(Object *obj, FuncArg *args) {}
-static ObjectList *CFunc_CopyObjectList(ObjectList *list) {}
-static void SetupFunctionArguments(Object *obj, DeclInfo *declinfo) {}
-NameSpace *CFunc_FuncGenSetup(Statement *stmt, Object *func) {}
-void CFunc_GetGlobalCompilerState(CFuncSave *state) {}
-void CFunc_SetGlobalCompilerState(CFuncSave *state) {}
-void CFunc_Gen(Statement *stmt, Object *obj, UInt8 unk) {}
-static void CFunc_CheckCtorInitializer(TypeClass *tclass, CtorChain *chain) {}
-void CFunc_CheckClassCtors(TypeClass *tclass) {}
-static void CFunc_ParseCtorInitializer(void) {}
-static void CFunc_FunctionRedefinedCheck(Object *obj) {}
-static Object *CFunc_DeclareFuncName(char *str, HashNameNode *name) {}
-void CFunc_ParseFuncDef(Object *obj, DeclInfo *declinfo, TypeClass *tclass, Boolean is_method, Boolean is_static, NameSpace *nspace) {}
-void InitExpr_Register(ENode *expr, Object *object) {}
-void CFunc_GenerateDummyFunction(Object *a) {}
-void CFunc_GenerateSingleExprFunc(Object *a, ENode *expr) {}
-void CFunc_GenerateDummyCtorFunc(Object *a, Object *b) {}
+// forward decls
+static void statement(DeclThing *thing);
+
+static void CFunc_LoopIncrement(void) {
+    if (curstmtvalue >= 0x1000) {
+        if (curstmtvalue >= 0xF000)
+            curstmtvalue++;
+        else
+            curstmtvalue += 0x1000;
+    } else {
+        curstmtvalue <<= 3;
+    }
+}
+
+static void CFunc_LoopDecrement(void) {
+    if (curstmtvalue > 0x1000) {
+        if (curstmtvalue > 0xF000)
+            curstmtvalue--;
+        else
+            curstmtvalue -= 0x1000;
+    } else {
+        curstmtvalue >>= 3;
+    }
+
+    if (curstmtvalue < 1)
+        curstmtvalue = 1;
+}
+
+DeclBlock *CFunc_NewDeclBlock(void) {
+    DeclBlock *block;
+    NameSpace *nspace;
+
+    block = lalloc(sizeof(DeclBlock));
+    if (firstblock) {
+        currentblock->next = block;
+        currentblock = block;
+    } else {
+        firstblock = block;
+        currentblock = block;
+    }
+
+    block->index = blockcount++;
+    block->parent_nspace = cscope_current;
+    block->dobjstack = cexcept_dobjstack;
+
+    nspace = CScope_NewListNameSpace(NULL, 0);
+    nspace->parent = cscope_current;
+    cscope_current = nspace;
+
+    return block;
+}
+
+void CFunc_RestoreBlock(DeclBlock *block) {
+    if (curstmt && curstmt->dobjstack != cexcept_dobjstack) {
+        Statement *stmt = CFunc_AppendStatement(ST_EXPRESSION);
+        stmt->expr = nullnode();
+    }
+
+    cscope_current = block->parent_nspace;
+    cexcept_dobjstack = block->dobjstack;
+}
+
+void CFunc_SetupLocalVarInfo(Object *obj) {
+    obj->u.var.info = CodeGen_GetNewVarInfo();
+    obj->u.var.info->func = cscope_currentfunc;
+
+    if (obj->sclass == TK_REGISTER) {
+        if (!copts.optimize_for_size)
+            obj->u.var.info->usage = 100;
+        else
+            obj->u.var.info->usage = 5;
+    }
+
+    if (obj->type && is_volatile_object(obj))
+        obj->u.var.info->noregister = 1;
+}
+
+static void adjustargumenttype(DeclInfo *declinfo) {
+    switch (declinfo->thetype->type) {
+        case TYPECLASS:
+            if (TYPE_CLASS(declinfo->thetype)->sominfo) {
+                CError_Error(CErrorStr284);
+                declinfo->thetype = TYPE(&stsignedint);
+            }
+            break;
+        case TYPEFUNC:
+            makethetypepointer(declinfo, 0);
+            return;
+        case TYPEARRAY:
+            declinfo->thetype = CDecl_NewPointerType(TPTR_TARGET(declinfo->thetype));
+            return;
+        case TYPETEMPLATE:
+            if (TYPE_TEMPLATE(declinfo->thetype)->dtype == TEMPLDEP_ARRAY)
+                declinfo->thetype = CDecl_NewPointerType(TYPE_TEMPLATE(declinfo->thetype)->u.array.type);
+            return;
+    }
+
+    if (!CanCreateObject(declinfo->thetype))
+        declinfo->thetype = TYPE(&stsignedint);
+}
+
+static FuncArg *CFunc_IsInArgList(FuncArg *list, HashNameNode *name) {
+    while (list) {
+        if (name == list->name)
+            return list;
+        list = list->next;
+    }
+
+    return NULL;
+}
+
+static Object *CFunc_IsInObjList(ObjectList *list, HashNameNode *name) {
+    while (list) {
+        if (name == list->object->name)
+            return list->object;
+        list = list->next;
+    }
+
+    return NULL;
+}
+
+static void CFunc_AppendArg(FuncArg **list, FuncArg *arg) {
+    FuncArg *tail;
+
+    if ((tail = *list)) {
+        while (tail->next)
+            tail = tail->next;
+        tail->next = arg;
+    } else {
+        *list = arg;
+    }
+}
+
+static void identifier_list(DeclInfo *declinfo) {
+    FuncArg *arg;
+
+    declinfo->x45 = 1;
+
+    while (1) {
+        if (tk != TK_IDENTIFIER) {
+            CError_Error(CErrorStr121);
+        } else {
+            if (CFunc_IsInArgList(declinfo->x18, tkidentifier))
+                CError_Error(CErrorStr122, tkidentifier->name);
+
+            arg = CParser_NewFuncArg();
+            arg->name = tkidentifier;
+            CFunc_AppendArg(&declinfo->x18, arg);
+            declinfo->x44 = 1;
+        }
+
+        if ((tk = lex()) != ',')
+            break;
+        tk = lex();
+    }
+}
+
+static Boolean defarg_name_obj_check(HashNameNode *name, Object *obj) {
+    FuncArg *arg;
+
+    if (name) {
+        for (arg = check_arglist; arg; arg = arg->next) {
+            if (arg->name == name) {
+                CError_Error(CErrorStr205);
+                return 0;
+            }
+        }
+    }
+
+    if (obj && obj->datatype == DLOCAL) {
+        CError_Error(CErrorStr205);
+        return 0;
+    }
+
+    return 1;
+}
+
+ENode *CFunc_DefaultArg(Type *type, UInt32 qual, FuncArg *args) {
+    TStreamElement *element;
+    ENode *expr;
+    ENode *templdepexpr;
+
+    name_obj_check = defarg_name_obj_check;
+    check_arglist = args;
+    expr = conv_assignment_expression();
+    name_obj_check = NULL;
+
+    if (
+        !CTemplTool_IsTemplateArgumentDependentExpression(expr) &&
+        !CTemplTool_IsTemplateArgumentDependentType(type)
+        )
+    {
+        expr = argumentpromotion(expr, type, qual, 1);
+    } else {
+        element = CPrep_CurStreamElement();
+        if (element && element->tokenfile) {
+            templdepexpr = CExpr_NewTemplDepENode(TDE_SOURCEREF);
+            templdepexpr->data.templdep.u.sourceref.expr = expr;
+            templdepexpr->data.templdep.u.sourceref.token = galloc(sizeof(TStreamElement));
+            *templdepexpr->data.templdep.u.sourceref.token = *element;
+            expr = templdepexpr;
+        }
+    }
+
+    return CInline_CopyExpression(expr, CopyMode1);
+}
+
+static FuncArg *parameter_list(DeclInfo *declinfo) {
+    Boolean flag26;
+    FuncArg *args;
+    FuncArg *arg;
+    DeclInfo my_di;
+    Boolean isArray;
+
+    args = NULL;
+    flag26 = 1;
+
+    while (1) {
+        if (tk == TK_ELLIPSIS) {
+            if (flag26) {
+                if (!copts.cplusplus && copts.ANSI_strict)
+                    CError_Warning(CErrorStr127);
+                args = &elipsis;
+            } else {
+                CFunc_AppendArg(&args, &elipsis);
+            }
+
+            tk = lex();
+            return args;
+        }
+
+        memclrw(&my_di, sizeof(my_di));
+        CParser_GetDeclSpecs(&my_di, 0);
+        if (my_di.x48)
+            CError_Error(CErrorStr127);
+
+        if (
+            my_di.storageclass &&
+            my_di.storageclass != TK_REGISTER &&
+            (!copts.cplusplus || my_di.storageclass != TK_AUTO)
+            )
+        {
+            CError_Error(CErrorStr127);
+            my_di.storageclass = 0;
+        }
+
+        my_di.name = NULL;
+
+        scandeclarator(&my_di);
+
+        if (flag26) {
+            flag26 = 0;
+            if (my_di.thetype == &stvoid) {
+                if (my_di.storageclass || my_di.qual || my_di.name)
+                    CError_Error(CErrorStr127);
+                return NULL;
+            }
+        }
+
+        isArray = IS_TYPE_ARRAY(my_di.thetype);
+        adjustargumenttype(&my_di);
+
+        if (my_di.name) {
+            if (args && CFunc_IsInArgList(args, my_di.name))
+                CError_Error(CErrorStr122, my_di.name->name);
+        } else {
+            my_di.name = no_name_node;
+        }
+
+        if (my_di.thetype == &stvoid)
+            CError_Error(CErrorStr126);
+
+        arg = CParser_NewFuncArg();
+        arg->name = my_di.name;
+        arg->type = my_di.thetype;
+        arg->qual = my_di.qual;
+        arg->sclass = my_di.storageclass;
+        arg->is_array = isArray;
+        CFunc_AppendArg(&args, arg);
+
+        if (copts.cplusplus && tk == '=') {
+            tk = lex();
+            arg->dexpr = CFunc_DefaultArg(arg->type, arg->qual, args);
+        }
+
+        if (tk != ',') {
+            if (tk != TK_ELLIPSIS || !copts.cplusplus)
+                return args;
+        } else {
+            tk = lex();
+        }
+    }
+}
+
+Boolean CFunc_ParseFakeArgList(Boolean flag) {
+    DeclInfo di;
+
+    if (tk == TK_ELLIPSIS)
+        return 1;
+
+    do {
+        memclrw(&di, sizeof(di));
+        CParser_GetDeclSpecs(&di, 0);
+
+        if (di.x48)
+            return 0;
+
+        scandeclarator(&di);
+
+        if (tk == '=') {
+            tk = lex();
+            assignment_expression();
+        }
+
+        switch (tk) {
+            case TK_ELLIPSIS:
+                return 1;
+            case ',':
+                if (!flag)
+                    tk = lex();
+                else
+                    return 1;
+                break;
+            default:
+                return 0;
+        }
+    } while (tk != TK_ELLIPSIS);
+
+    return 1;
+}
+
+FuncArg *parameter_type_list(DeclInfo *declinfo) {
+    FuncArg *args;
+    NameSpace *nspace;
+    Boolean save_in_func_arglist;
+
+    declinfo->x44 = 0;
+    declinfo->x45 = 0;
+    declinfo->x1C = NULL;
+
+    if (tk == TK_ELLIPSIS || isdeclaration(0, 0, 0, 0)) {
+        if (!copts.cplusplus) {
+            nspace = CScope_NewListNameSpace(NULL, 0);
+            nspace->parent = cscope_current;
+            cscope_current = nspace;
+
+            save_in_func_arglist = in_func_arglist;
+            in_func_arglist = 1;
+            args = parameter_list(declinfo);
+            in_func_arglist = save_in_func_arglist;
+
+            cscope_current = nspace->parent;
+
+            if (!CScope_IsEmptyNameSpace(nspace))
+                declinfo->x1C = nspace;
+        } else {
+            args = parameter_list(declinfo);
+        }
+    } else if (copts.cplusplus) {
+        args = NULL;
+        if (tk != ')')
+            CError_Error(CErrorStr127);
+    } else {
+        identifier_list(declinfo);
+        args = &oldstyle;
+    }
+
+    return args;
+}
+
+CLabel *findlabel(void) {
+    CLabel *scan;
+
+    for (scan = Labels; scan; scan = scan->next) {
+        if (tkidentifier == scan->name)
+            return scan;
+    }
+
+    return NULL;
+}
+
+CLabel *newlabel(void) {
+    CLabel *label = lalloc(sizeof(CLabel));
+    memclrw(label, sizeof(CLabel));
+
+    label->name = label->uniquename = CParser_GetUniqueName();
+    return label;
+}
+
+Statement *CFunc_AppendStatement(StatementType sttype) {
+    Statement *stmt = lalloc(sizeof(Statement));
+
+    stmt->next = NULL;
+    stmt->type = sttype;
+    stmt->value = curstmtvalue;
+    stmt->flags = 0;
+    stmt->sourceoffset = sourceoffset;
+    stmt->sourcefilepath = sourcefilepath;
+    stmt->dobjstack = cexcept_dobjstack;
+
+    curstmt->next = stmt;
+    curstmt = stmt;
+    return stmt;
+}
+
+Statement *CFunc_InsertStatement(StatementType sttype, Statement *after) {
+    Statement *stmt = lalloc(sizeof(Statement));
+
+    stmt->next = after->next;
+    after->next = stmt;
+    stmt->type = sttype;
+    stmt->value = after->value;
+    stmt->flags = 0;
+    stmt->sourceoffset = after->sourceoffset;
+    stmt->sourcefilepath = after->sourcefilepath;
+    stmt->dobjstack = after->dobjstack;
+
+    return stmt;
+}
+
+Statement *CFunc_InsertBeforeStatement(StatementType sttype, Statement *before) {
+    Statement *stmt = lalloc(sizeof(Statement));
+
+    *stmt = *before;
+    before->next = stmt;
+    before->type = sttype;
+    before->flags = 0;
+
+    return before;
+}
+
+void CheckCLabels(void) {
+    CLabel *scan;
+
+    for (scan = Labels; scan; scan = scan->next) {
+        if (!scan->stmt)
+            CError_Error(CErrorStr159, scan->name->name);
+    }
+}
+
+Object *create_temp_object(Type *type) {
+    Object *object = CParser_NewLocalDataObject(NULL, 1);
+    object->name = CParser_GetUniqueName();
+    object->type = type;
+    CFunc_SetupLocalVarInfo(object);
+    return object;
+}
+
+ENode *create_temp_node(Type *type) {
+    ENode *node;
+
+    if (cinit_tempnodefunc)
+        return cinit_tempnodefunc(type, 0);
+
+    node = CExpr_NewETEMPNode(type, 0);
+    if (IS_TYPE_CLASS(type) && CClass_Destructor(TYPE_CLASS(type)))
+        node->data.temp.needs_dtor = 1;
+    return node;
+}
+
+ENode *create_temp_node2(Type *type) {
+    ENode *node;
+
+    if (cinit_tempnodefunc)
+        return cinit_tempnodefunc(type, 1);
+
+    node = CExpr_NewETEMPNode(type, 0);
+    node->data.temp.needs_dtor = 1;
+    return node;
+}
+
+static ENode *CFunc_DestroyReverse(ENode *expr, DtorTemp *list) {
+    expr = makediadicnode(expr, CABI_DestroyObject(list->dtor, create_objectrefnode(list->object), CABIDestroy1, 1, 0), ECOMMA);
+    expr->rtype = &stvoid;
+    if (list->next)
+        expr = CFunc_DestroyReverse(expr, list->next);
+    return expr;
+}
+
+static ENode *CFunc_TempTransDestroy(ENode *expr, DtorTemp *list, Boolean flag) {
+    Object *tempobj;
+
+    if (flag) {
+        CError_ASSERT(738, !(IS_TYPE_CLASS(expr->rtype) && CClass_Destructor(TYPE_CLASS(expr->rtype))));
+        tempobj = create_temp_object(expr->rtype);
+        expr = makediadicnode(create_objectnode(tempobj), expr, EASS);
+    }
+
+    expr = CFunc_DestroyReverse(expr, list);
+
+    if (flag) {
+        expr = makediadicnode(expr, create_objectnode(tempobj), ECOMMA);
+        expr->rtype = tempobj->type;
+    }
+
+    return expr;
+}
+
+void CFunc_WarnUnused(void) {
+    if (copts.warn_unusedvar) {
+        ObjectList *list;
+        for (list = locals; list; list = list->next) {
+            if (
+                !(list->object->flags & OBJECT_FLAGS_UNUSED) &&
+                !IsTempName(list->object->name) &&
+                !(list->object->qual & Q_10000)
+                )
+            {
+                CError_SetErrorToken(&list->object->u.var.info->deftoken);
+                CError_Warning(CErrorStr182, &list->object->name->name);
+            }
+        }
+    }
+
+    if (copts.warn_unusedarg) {
+        ObjectList *list;
+        for (list = arguments; list; list = list->next) {
+            if (
+                !(list->object->flags & OBJECT_FLAGS_UNUSED) &&
+                !IsTempName(list->object->name) &&
+                list->object->name != this_name_node &&
+                list->object->name != self_name_node
+                )
+            {
+                CError_SetErrorToken(&symdecltoken);
+                CError_Warning(CErrorStr182, &list->object->name->name);
+            }
+        }
+    }
+}
+
+void CFunc_CodeCleanup(Statement *stmt) {
+    if (cscope_currentclass && cscope_currentclass->sominfo)
+        CSOM_InitSOMSelf(cscope_currentclass, stmt);
+
+    CFunc_WarnUnused();
+    CExcept_ExceptionTansform(stmt);
+}
+
+static Boolean DestructorNeeded(ExceptionAction *ea, ExceptionAction *end) {
+    while (ea) {
+        if (CExcept_ActionNeedsDestruction(ea))
+            return 1;
+        if (ea == end)
+            break;
+        ea = ea->prev;
+    }
+
+    return 0;
+}
+
+static Statement *DestructLocals(Statement *stmt, ExceptionAction *ea, ExceptionAction *end) {
+    while (ea) {
+        stmt = CExcept_ActionCleanup(ea, stmt);
+        if (ea == end)
+            break;
+        ea = ea->prev;
+    }
+
+    return stmt;
+}
+
+static Boolean NeedsDestruction(Statement *stmt1, Statement *stmt2) {
+    ExceptionAction *ea2;
+    ExceptionAction *ea1;
+    ExceptionAction *scan;
+
+    ea1 = stmt1->dobjstack;
+    ea2 = stmt2->dobjstack;
+
+    for (scan = ea2; scan; scan = scan->prev) {
+        if (scan == ea1)
+            return 0;
+    }
+
+    while (ea1 && ea1 != ea2) {
+        if (CExcept_ActionNeedsDestruction(ea1))
+            return 1;
+        ea1 = ea1->prev;
+    }
+
+    return 0;
+}
+
+static ExceptionAction *FindLastNonCommonStackObj(Statement *stmt1, Statement *stmt2) {
+    ExceptionAction *ea1;
+    ExceptionAction *ea2;
+
+    for (ea2 = stmt2->dobjstack; ea2; ea2 = ea2->prev) {
+        for (ea1 = stmt1->dobjstack; ea1; ea1 = ea1->prev) {
+            if (ea1->prev == ea2)
+                return ea1;
+        }
+    }
+
+    return NULL;
+}
+
+static void DestructorReturnTransform(Statement *stmt1, Statement *stmt2) {
+    Statement *stmt;
+    Object *tempobj;
+
+    if (stmt1->dobjstack != stmt2->dobjstack && NeedsDestruction(stmt1, stmt2))
+        stmt1 = DestructLocals(stmt1, stmt1->dobjstack, FindLastNonCommonStackObj(stmt1, stmt2));
+
+    if (DestructorNeeded(stmt2->dobjstack, NULL)) {
+        if (CMach_GetFunctionResultClass(TYPE_FUNC(cscope_currentfunc->type)) != 1) {
+            tempobj = create_temp_object(stmt2->expr->rtype);
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt1);
+            stmt->expr = makediadicnode(create_objectnode(tempobj), stmt2->expr, EASS);
+            stmt->sourceoffset = stmt2->sourceoffset;
+            stmt->sourcefilepath = stmt2->sourcefilepath;
+            DestructLocals(stmt, stmt2->dobjstack, NULL);
+            stmt2->expr = create_objectnode(tempobj);
+        } else {
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt1);
+            stmt->expr = stmt2->expr;
+            stmt->sourceoffset = stmt2->sourceoffset;
+            stmt->sourcefilepath = stmt2->sourcefilepath;
+            DestructLocals(stmt, stmt2->dobjstack, NULL);
+            stmt2->expr = nullnode();
+        }
+    }
+}
+
+static Statement *DestructorIfTransform(Statement *stmt) {
+    CLabel *label;
+    Statement *newStmt;
+
+    if (stmt->type == ST_IFGOTO)
+        stmt->type = ST_IFNGOTO;
+    else
+        stmt->type = ST_IFGOTO;
+
+    label = newlabel();
+    newStmt = DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, stmt->label->stmt));
+    newStmt = CFunc_InsertStatement(ST_GOTO, newStmt);
+    newStmt->label = stmt->label;
+    newStmt = CFunc_InsertStatement(ST_LABEL, newStmt);
+    newStmt->label = label;
+    label->stmt = newStmt;
+    stmt->label = label;
+    newStmt->dobjstack = stmt->dobjstack;
+    return newStmt;
+}
+
+static Boolean IsSubStack(ExceptionAction *exc1, ExceptionAction *exc2) {
+    if (!exc1)
+        return 1;
+
+    while (exc2) {
+        if (exc2 == exc1)
+            return 1;
+        exc2 = exc2->prev;
+    }
+
+    return 0;
+}
+
+static void CFunc_CheckInitSkip(Statement *stmt, ExceptionAction *exc) {
+    if (stmt->dobjstack != exc && !IsSubStack(exc, stmt->dobjstack)) {
+        while (exc) {
+            if (CExcept_ActionNeedsDestruction(exc) && exc->type != EAT_ACTIVECATCHBLOCK) {
+                CError_Warning(CErrorStr211);
+                break;
+            }
+            exc = exc->prev;
+        }
+    }
+}
+
+void CFunc_DestructorCleanup(Statement *stmt) {
+    Statement *scan;
+    Statement *next;
+    SwitchCase *swcase;
+
+    if (copts.cplusplus) {
+        for (scan = stmt; scan; scan = scan->next) {
+            switch (scan->type) {
+                case ST_NOP:
+                case ST_LABEL:
+                case ST_EXPRESSION:
+                case ST_RETURN:
+                case ST_BEGINCATCH:
+                case ST_ENDCATCH:
+                case ST_ENDCATCHDTOR:
+                case ST_GOTOEXPR:
+                case ST_ASM:
+                    break;
+                case ST_SWITCH:
+                    CFunc_CheckInitSkip(scan, ((SwitchInfo *) scan->label)->defaultlabel->stmt->dobjstack);
+                    for (swcase = ((SwitchInfo *) scan->label)->cases; swcase; swcase = swcase->next) {
+                        CFunc_CheckInitSkip(scan, swcase->label->stmt->dobjstack);
+                    }
+                    break;
+                case ST_GOTO:
+                case ST_IFGOTO:
+                case ST_IFNGOTO:
+                    CFunc_CheckInitSkip(scan, scan->label->stmt->dobjstack);
+                    break;
+                default:
+                    CError_FATAL(1045);
+            }
+        }
+
+        if (cexcept_hasdobjects) {
+            while (1) {
+                next = stmt->next;
+                if (!next) {
+                    if (stmt->type != ST_RETURN && stmt->dobjstack)
+                        DestructLocals(stmt, stmt->dobjstack, NULL);
+                    return;
+                }
+
+                switch (next->type) {
+                    case ST_GOTO:
+                        if (
+                            stmt->dobjstack != next->label->stmt->dobjstack &&
+                            NeedsDestruction(stmt, next->label->stmt)
+                            )
+                        {
+                            DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, next->label->stmt));
+                        }
+                        stmt = next;
+                        continue;
+
+                    case ST_RETURN:
+                        if (next->expr && DestructorNeeded(stmt->dobjstack, NULL)) {
+                            DestructorReturnTransform(stmt, next);
+                        } else if (stmt->dobjstack) {
+                            DestructLocals(stmt, stmt->dobjstack, NULL);
+                        }
+                        stmt = next;
+                        continue;
+                }
+
+                switch (stmt->type) {
+                    case ST_GOTO:
+                    case ST_SWITCH:
+                    case ST_RETURN:
+                    case ST_GOTOEXPR:
+                        break;
+                    case ST_NOP:
+                    case ST_LABEL:
+                    case ST_EXPRESSION:
+                    case ST_IFGOTO:
+                    case ST_IFNGOTO:
+                    case ST_BEGINCATCH:
+                    case ST_ENDCATCH:
+                    case ST_ENDCATCHDTOR:
+                    case ST_ASM:
+                        if (
+                            stmt->dobjstack != next->dobjstack &&
+                            NeedsDestruction(stmt, next)
+                            )
+                        {
+                            DestructLocals(stmt, stmt->dobjstack, FindLastNonCommonStackObj(stmt, next));
+                        }
+                        break;
+                    default:
+                        CError_FATAL(1109);
+                }
+
+                switch (next->type) {
+                    case ST_NOP:
+                    case ST_LABEL:
+                    case ST_EXPRESSION:
+                    case ST_SWITCH:
+                    case ST_BEGINCATCH:
+                    case ST_ENDCATCH:
+                    case ST_ENDCATCHDTOR:
+                    case ST_ASM:
+                        stmt = next;
+                        continue;
+
+                    case ST_IFGOTO:
+                    case ST_IFNGOTO:
+                        if (
+                            next->dobjstack != next->label->stmt->dobjstack &&
+                            NeedsDestruction(next, next->label->stmt)
+                            )
+                        {
+                            stmt = DestructorIfTransform(next);
+                        } else {
+                            stmt = next;
+                        }
+                        break;
+
+                    default:
+                        CError_FATAL(1138);
+                }
+            }
+        }
+    }
+}
+
+static void scancase(DeclThing *thing) {
+    SwitchCase *swcase;
+    Statement *stmt;
+    CInt64 min;
+    CInt64 max;
+
+    if (!thing->switchinfo) {
+        CError_Error(CErrorStr169);
+        return;
+    }
+
+    tk = lex();
+    min = CExpr_IntConstConvert(thing->switchinfo->x8, thing->switchinfo->x8, CExpr_IntegralConstExpr());
+    if (!copts.ANSI_strict && tk == TK_ELLIPSIS) {
+        tk = lex();
+        max = CExpr_IntConstConvert(thing->switchinfo->x8, thing->switchinfo->x8, CExpr_IntegralConstExpr());
+        if (CInt64_Greater(min, max))
+            CError_Error(CErrorStr366);
+        if (thing->switchinfo->x8->size == stsignedlonglong.size)
+            CError_Error(CErrorStr368);
+    } else {
+        max = min;
+    }
+
+    for (swcase = thing->switchinfo->cases; swcase; swcase = swcase->next) {
+        if (CInt64_GreaterEqual(swcase->min, min) && CInt64_LessEqual(swcase->min, max))
+            CError_Error(CErrorStr172);
+        if (CInt64_GreaterEqual(swcase->max, min) && CInt64_LessEqual(swcase->max, max))
+            CError_Error(CErrorStr172);
+        if (CInt64_Less(swcase->min, min) && CInt64_Greater(swcase->max, max))
+            CError_Error(CErrorStr172);
+    }
+
+    stmt = CFunc_AppendStatement(ST_LABEL);
+    stmt->label = newlabel();
+    stmt->label->stmt = stmt;
+
+    swcase = lalloc(sizeof(SwitchCase));
+    swcase->min = min;
+    swcase->label = stmt->label;
+    swcase->next = thing->switchinfo->cases;
+    thing->switchinfo->cases = swcase;
+    swcase->max = max;
+
+    if (tk != ':')
+        CError_ErrorSkip(CErrorStr170);
+    else
+        tk = lex();
+
+    statement(thing);
+}
+
+static void CFunc_NameLocalStaticDataObject(Object *obj, char *str) {
+    char buf[64];
+    HashNameNode *name;
+
+    if (!(cscope_currentfunc && (cscope_currentfunc->qual & Q_INLINE)) || CParser_HasInternalLinkage(cscope_currentfunc)) {
+        obj->name = CParser_AppendUniqueName(str);
+    } else {
+        sprintf(buf, "$localstatic%ld$", cfunc_staticvarcount++);
+        name = CMangler_GetLinkName(cscope_currentfunc);
+        name = CParser_NameConcat(buf, name->name);
+        name = CParser_NameConcat(str, name->name);
+        obj->name = name;
+        obj->qual |= Q_20000;
+        obj->sclass = 0;
+    }
+}
+
+static void sinit_insert_expr(ENode *expr) {
+    Statement *stmt;
+
+    if (!sinit_first_object) {
+        sinit_first_object = CParser_NewCompilerDefDataObject();
+        sinit_first_object->type = TYPE(&stsignedchar);
+        sinit_first_object->sclass = TK_STATIC;
+        CFunc_NameLocalStaticDataObject(sinit_first_object, "init");
+        CInit_DeclareData(sinit_first_object, NULL, NULL, sinit_first_object->type->size);
+
+        sinit_label = newlabel();
+        stmt = CFunc_AppendStatement(ST_IFGOTO);
+        stmt->expr = create_objectnode(sinit_first_object);
+        stmt->label = sinit_label;
+    }
+
+    stmt = CFunc_AppendStatement(ST_EXPRESSION);
+    stmt->expr = expr;
+}
+
+static void ainit_insert_expr(ENode *expr) {
+    Statement *stmt;
+
+    if (ainit_only_one) {
+        if (ainit_expr) {
+            stmt = CFunc_AppendStatement(ST_EXPRESSION);
+            stmt->expr = ainit_expr;
+        }
+        ainit_expr = expr;
+    } else {
+        stmt = CFunc_AppendStatement(ST_EXPRESSION);
+        stmt->expr = expr;
+    }
+}
+
+static ENode *ainit_register_object(Type *type, Object *local, SInt32 offset, Boolean flag) {
+    return CExcept_RegisterDestructorObject(local, offset, CClass_Destructor(TYPE_CLASS(type)), flag);
+}
+
+static void CFunc_LocalDataDeclarator(DeclInfo *di, TStreamElement *deftoken, Boolean flag1, Boolean flag2) {
+    Object *object;
+    Object *aliasObject;
+    NameSpace *globalNS;
+    NameSpaceObjectList *nsol;
+    NameSpaceName *nsname;
+    Statement *stmt;
+
+    if (di->nspace)
+        CError_Error(CErrorStr121);
+
+    CDecl_CompleteType(di->thetype);
+
+    object = NULL;
+
+    if ((nsol = CScope_FindName(cscope_current, di->name))) {
+        switch (nsol->object->otype) {
+            case OT_OBJECT:
+                object = OBJECT(nsol->object);
+                break;
+            case OT_NAMESPACE:
+                CError_Error(CErrorStr321);
+                return;
+            case OT_ENUMCONST:
+            case OT_TYPE:
+                CError_Error(CErrorStr322);
+                break;
+            case OT_TYPETAG:
+                break;
+            default:
+                CError_FATAL(1344);
+        }
+    }
+
+    if (object)
+        CError_Error(CErrorStr333, object);
+
+    if (di->storageclass == TK_EXTERN) {
+        object = NULL;
+        globalNS = CScope_FindGlobalNS(cscope_current);
+        if ((nsol = CScope_FindName(globalNS, di->name))) {
+            switch (nsol->object->otype) {
+                case OT_OBJECT:
+                    object = OBJECT(nsol->object);
+                    break;
+                case OT_NAMESPACE:
+                    CError_Error(CErrorStr321);
+                    return;
+                case OT_ENUMCONST:
+                case OT_TYPE:
+                    CError_Error(CErrorStr322);
+                    break;
+                case OT_TYPETAG:
+                    break;
+                default:
+                    CError_FATAL(1381);
+            }
+        }
+
+        if (object) {
+            if (
+                !is_typesame(di->thetype, object->type) ||
+                (di->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK)) != (object->qual & (Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK))
+                )
+            {
+                CError_Error(CErrorStr249, di->name->name, object->type, object->qual, di->thetype, di->qual);
+            }
+        } else {
+            object = CParser_NewGlobalDataObject(di);
+            object->nspace = globalNS;
+        }
+
+        CParser_NewAliasObject(object, 0);
+        return;
+    }
+
+    if (di->storageclass != TK_STATIC)
+        object = CParser_NewObject(di);
+    else
+        object = CParser_NewGlobalDataObject(di);
+
+    object->name = di->name;
+    object->type = di->thetype;
+    object->qual = di->qual;
+    object->sclass = di->storageclass;
+
+    switch (di->storageclass) {
+        case TK_STATIC:
+            if (flag1) {
+                CError_Error(CErrorStr177);
+                return;
+            }
+            if (flag2)
+                CError_Error(CErrorStr174);
+
+            if (CanCreateObject(di->thetype)) {
+                CError_QualifierCheck(di->qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_20000 | Q_OVERLOAD | Q_ALIGNED_MASK));
+                CParser_NewAliasObject(object, 0);
+                object->nspace = cscope_root;
+                object->datatype = DDATA;
+                CFunc_NameLocalStaticDataObject(object, object->name->name);
+
+                if (copts.cplusplus) {
+                    sinit_first_object = NULL;
+                    CInit_InitializeStaticData(object, sinit_insert_expr);
+                    if (sinit_first_object) {
+                        stmt = CFunc_AppendStatement(ST_EXPRESSION);
+                        stmt->expr = makediadicnode(
+                            create_objectnode(sinit_first_object),
+                            intconstnode(TYPE(&stsignedchar), 1),
+                            EASS);
+                        stmt = CFunc_AppendStatement(ST_LABEL);
+                        stmt->label = sinit_label;
+                        sinit_label->stmt = stmt;
+                    }
+                } else {
+                    CInit_InitializeData(object);
+                }
+            }
+            break;
+
+        case 0:
+        case TK_AUTO:
+        case TK_REGISTER:
+            if (CanCreateObject(di->thetype)) {
+                CError_QualifierCheck(di->qual & ~(Q_CONST | Q_VOLATILE | Q_PASCAL | Q_ALIGNED_MASK));
+                object->datatype = DLOCAL;
+                CFunc_SetupLocalVarInfo(object);
+
+                object->u.var.info->deftoken = *deftoken;
+                if (object->sclass == TK_REGISTER && flag1)
+                    object->u.var.info->usage = 100;
+
+                CScope_AddObject(cscope_current, object->name, OBJ_BASE(object));
+
+                if (!flag1) {
+                    if (IS_TYPE_SOM_CLASS(di->thetype)) {
+                        CSOM_InitAutoClass(object);
+                    } else {
+                        CInit_InitializeAutoData(object, ainit_insert_expr, ainit_register_object);
+                        if (object->type != di->thetype && (IS_TYPE_STRUCT(object->type) || IS_TYPE_CLASS(object->type))) {
+                            CError_ASSERT(1478, !cscope_current->is_hash);
+                            CError_ASSERT(1479, nsname = CScope_FindNameSpaceName(cscope_current, object->name));
+                            CError_ASSERT(1480, nsname->first.object == OBJ_BASE(object));
+                            CError_ASSERT(1481, !nsname->first.next);
+                            nsname->name = CParser_AppendUniqueName(object->name->name);
+
+                            aliasObject = CParser_NewAliasObject(object, 0);
+                            aliasObject->type = di->thetype;
+                        }
+                    }
+                }
+
+                if (object->datatype == DLOCAL) {
+                    ObjectList *list = lalloc(sizeof(ObjectList));
+                    list->object = object;
+                    list->next = locals;
+                    locals = list;
+                }
+
+                IsCompleteType(di->thetype);
+            }
+            break;
+
+        default:
+            CError_FATAL(1504);
+    }
+}
+
+static ENode *CFunc_ParseLocalDeclarationList(Boolean flag1, Boolean flag2, Boolean flag3, Boolean flag4) {
+    Type *type;
+    UInt32 qual;
+    DeclInfo di;
+    TStreamElement deftoken;
+
+    ainit_expr = NULL;
+    ainit_only_one = flag2;
+
+    while (flag2 || isdeclaration(copts.cplusplus, 0, 0, 0)) {
+        CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+
+        memclrw(&di, sizeof(di));
+        di.x4E = cfunc_is_extern_c;
+        CParser_GetDeclSpecs(&di, 0);
+
+        if (IS_TYPE_TEMPLATE(di.thetype)) {
+            CError_Error(CErrorStr146);
+            di.thetype = TYPE(&stsignedint);
+        }
+
+        type = di.thetype;
+        qual = di.qual;
+
+        if (tk != ';') {
+            while (1) {
+                deftoken = *CPrep_CurStreamElement();
+                di.name = NULL;
+                scandeclarator(&di);
+
+                if (di.name) {
+                    if (di.storageclass != TK_TYPEDEF) {
+                        if (IS_TYPE_FUNC(di.thetype)) {
+                            if (!CDecl_FunctionDeclarator(&di, CScope_FindGlobalNS(cscope_current), 0, 0))
+                                break;
+                        } else {
+                            CFunc_LocalDataDeclarator(&di, &deftoken, flag1, flag2);
+                        }
+                    } else {
+                        CDecl_TypedefDeclarator(&di);
+                    }
+                } else {
+                    CError_Error(CErrorStr134);
+                }
+
+                if (tk == ';')
+                    break;
+
+                if (tk != ',') {
+                    if (!flag2)
+                        CError_Error(CErrorStr123);
+                    break;
+                }
+
+                di.nspace = NULL;
+                di.thetype = type;
+                di.qual = qual;
+                tk = lex();
+            }
+        } else {
+            CParser_CheckAnonymousUnion(&di, 1);
+        }
+
+        if (flag2)
+            break;
+        if (flag4)
+            break;
+        tk = lex();
+    }
+
+    if (flag2) {
+        if (!ainit_expr) {
+            if (!flag3) {
+                CError_Error(CErrorStr141);
+                ainit_expr = nullnode();
+            }
+        } else {
+            ainit_expr = checkreference(ainit_expr);
+        }
+    }
+
+    return ainit_expr;
+}
+
+static void makeifstatement(ENode *expr, CLabel *label1, CLabel *label2, Boolean flag1, Boolean flag2) {
+    Statement *stmt;
+    CLabel *tmplabel;
+
+    if (!expr) {
+        if (flag1) {
+            stmt = CFunc_AppendStatement(ST_GOTO);
+            stmt->label = label1;
+            return;
+        }
+        return;
+    }
+
+    if (
+        ENODE_IS(expr, ETYPCON) &&
+        IS_TYPE_INT(expr->rtype) &&
+        IS_TYPE_INT(expr->data.monadic->rtype) &&
+        expr->rtype->size >= expr->data.monadic->rtype->size
+        )
+        expr = expr->data.monadic;
+
+    if (isnotzero(expr)) {
+        if (flag1) {
+            stmt = CFunc_AppendStatement(ST_GOTO);
+            stmt->label = label1;
+            return;
+        }
+        return;
+    }
+
+    if (iszero(expr)) {
+        if (!flag1) {
+            stmt = CFunc_AppendStatement(ST_GOTO);
+            stmt->label = label1;
+            return;
+        }
+        return;
+    }
+
+    if (ENODE_IS(expr, ELOGNOT)) {
+        makeifstatement(expr->data.monadic, label1, label2, !flag1, flag2);
+        return;
+    }
+
+    if (ENODE_IS(expr, ELOR)) {
+        tmplabel = newlabel();
+        if (flag1) {
+            makeifstatement(expr->data.diadic.left, label1, tmplabel, 1, flag2);
+            tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+            tmplabel->stmt->label = tmplabel;
+            makeifstatement(expr->data.diadic.right, label1, label2, 1, flag2);
+            return;
+        } else {
+            makeifstatement(expr->data.diadic.left, label2, tmplabel, 1, flag2);
+            tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+            tmplabel->stmt->label = tmplabel;
+            makeifstatement(expr->data.diadic.right, label1, label2, 0, flag2);
+            return;
+        }
+    }
+
+    if (ENODE_IS(expr, ELAND)) {
+        tmplabel = newlabel();
+        if (flag1) {
+            makeifstatement(expr->data.diadic.left, label2, tmplabel, 0, flag2);
+            tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+            tmplabel->stmt->label = tmplabel;
+            makeifstatement(expr->data.diadic.right, label1, label2, 1, flag2);
+            return;
+        } else {
+            makeifstatement(expr->data.diadic.left, label1, tmplabel, 0, flag2);
+            tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+            tmplabel->stmt->label = tmplabel;
+            makeifstatement(expr->data.diadic.right, label1, label2, 0, flag2);
+            return;
+        }
+    }
+
+    stmt = CFunc_AppendStatement(ST_IFGOTO);
+    stmt->label = label1;
+    stmt->expr = expr;
+    if (!flag1)
+        stmt->type = ST_IFNGOTO;
+    if (flag2)
+        stmt->flags |= StmtFlag_4;
+}
+
+static void CFunc_HasDtorTempCallBack(ENode *expr) {
+    if (expr->data.temp.needs_dtor || expr->data.temp.uniqueid)
+        cfunc_hasdtortemp = 1;
+}
+
+static void ifstatement(Boolean flag1, ENode *expr, CLabel *label, Boolean flag2) {
+    Statement *stmt;
+    CLabel *tmplabel;
+
+    if (expr && copts.cplusplus && copts.exceptions) {
+        cfunc_hasdtortemp = 0;
+        CExpr_SearchExprTree(expr, CFunc_HasDtorTempCallBack, 1, ETEMP);
+        if (cfunc_hasdtortemp) {
+            stmt = CFunc_AppendStatement(flag1 ? ST_IFGOTO : ST_IFNGOTO);
+            stmt->label = label;
+            stmt->expr = expr;
+            if (flag2)
+                stmt->flags |= StmtFlag_4;
+            return;
+        }
+    }
+
+    tmplabel = newlabel();
+    makeifstatement(expr, label, tmplabel, flag1, flag2);
+    tmplabel->stmt = CFunc_AppendStatement(ST_LABEL);
+    tmplabel->stmt->label = tmplabel;
+}
+
+Statement *CFunc_GenerateLoop(Statement *stmt, Type *type, ENode *lowerBound, ENode *upperBound, ENode *increment1, ENode *increment2, ENode *(*callback)(ENode *, ENode *)) {
+    ENode *var1;
+    ENode *var2;
+    CLabel *label;
+    ENode *ind;
+    ENode *ind2;
+    Statement *s;
+
+    var1 = CExpr_NewETEMPNode(type, 1);
+    ind = lalloc(sizeof(ENode));
+    *ind = *var1;
+    ind = makemonadicnode(ind, EINDIRECT);
+    ind->rtype = type;
+
+    // initialise var1 to lowerBound
+    if (stmt) {
+        stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+        s = stmt;
+    } else {
+        s = CFunc_AppendStatement(ST_EXPRESSION);
+    }
+    s->expr = makediadicnode(ind, lowerBound, EASS);
+
+    if (increment2) {
+        var2 = CExpr_NewETEMPNode(type, 1);
+        ind = lalloc(sizeof(ENode));
+        *ind = *var2;
+        ind = makemonadicnode(ind, EINDIRECT);
+        ind->rtype = type;
+
+        // initialise var2 to upperBound
+        if (stmt) {
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            s = stmt;
+        } else {
+            s = CFunc_AppendStatement(ST_EXPRESSION);
+        }
+        s->expr = makediadicnode(ind, upperBound, EASS);
+    }
+
+    // label for loop body
+    label = newlabel();
+    if (stmt) {
+        stmt = CFunc_InsertStatement(ST_LABEL, stmt);
+        s = stmt;
+    } else {
+        s = CFunc_AppendStatement(ST_LABEL);
+    }
+    s->label = label;
+    label->stmt = s;
+
+    if (callback) {
+        ind = lalloc(sizeof(ENode));
+        *ind = *var1;
+        ind = makemonadicnode(ind, EINDIRECT);
+        ind->rtype = type;
+
+        if (increment2) {
+            ind2 = lalloc(sizeof(ENode));
+            *ind2 = *var2;
+            ind2 = makemonadicnode(ind2, EINDIRECT);
+            ind2->rtype = type;
+        } else {
+            ind2 = NULL;
+        }
+
+        // generate a loop body
+        if ((ind = callback(ind, ind2))) {
+            if (stmt) {
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                s = stmt;
+            } else {
+                s = CFunc_AppendStatement(ST_EXPRESSION);
+            }
+            s->expr = ind;
+        }
+    }
+
+    if (increment1) {
+        ind = lalloc(sizeof(ENode));
+        *ind = *var1;
+        ind = makemonadicnode(ind, EINDIRECT);
+        ind->rtype = type;
+
+        // add increment1 to var1
+        if (stmt) {
+            stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+            s = stmt;
+        } else {
+            s = CFunc_AppendStatement(ST_EXPRESSION);
+        }
+        s->expr = makediadicnode(ind, increment1, EADDASS);
+
+        if (increment2) {
+            ind = lalloc(sizeof(ENode));
+            *ind = *var2;
+            ind = makemonadicnode(ind, EINDIRECT);
+            ind->rtype = type;
+
+            // add increment2 to var2
+            if (stmt) {
+                stmt = CFunc_InsertStatement(ST_EXPRESSION, stmt);
+                s = stmt;
+            } else {
+                s = CFunc_AppendStatement(ST_EXPRESSION);
+            }
+            s->expr = makediadicnode(ind, increment2, EADDASS);
+        }
+    }
+
+    ind = lalloc(sizeof(ENode));
+    *ind = *var1;
+    ind = makemonadicnode(ind, EINDIRECT);
+    ind->rtype = type;
+
+    // loop if var1 < upperBound
+    if (stmt) {
+        stmt = CFunc_InsertStatement(ST_IFGOTO, stmt);
+        s = stmt;
+    } else {
+        s = CFunc_AppendStatement(ST_IFGOTO);
+    }
+    s->expr = makediadicnode(ind, upperBound, ELESS);
+    s->expr->rtype = TYPE(&stbool);
+    s->label = label;
+    s->flags = StmtFlag_4;
+
+    return stmt;
+}
+
+static Boolean checklabel(void) {
+    HashNameNode *savename;
+    short savesize;
+    short token;
+
+    savename = tkidentifier;
+    savesize = tksize;
+    token = lookahead();
+    tkidentifier = savename;
+    tksize = savesize;
+
+    return token == ':';
+}
+
+static ENode *returnstatementadjust(ENode *expr, Type *type, UInt32 qual) {
+    Object *object;
+    ENode *expr2;
+    ENode *objexpr;
+    ObjectList *list;
+    ENodeList *exprlist;
+
+    for (list = arguments; list; list = list->next) {
+        if (list->object->name == temp_argument_name)
+            break;
+    }
+
+    CError_ASSERT(1907, list);
+
+    object = list->object;
+    if ((expr2 = CExpr_IsTempConstruction(expr, type, &objexpr)) && ENODE_IS(objexpr, ETEMP)) {
+        *objexpr = *create_objectnode(object);
+        return expr2;
+    }
+
+    if (IS_TYPE_CLASS(type)) {
+        expr2 = create_objectnode(object);
+        exprlist = lalloc(sizeof(ENodeList));
+        exprlist->next = NULL;
+        exprlist->node = expr;
+        return CExpr_ConstructObject(TYPE_CLASS(type), expr2, exprlist, 1, 1, 0, 1, 0);
+    }
+
+    expr2 = create_objectnode(object);
+    expr2 = makemonadicnode(expr2, EINDIRECT);
+    expr2->rtype = type;
+
+    return makediadicnode(expr2, CExpr_AssignmentPromotion(expr, type, qual, 1), EASS);
+}
+
+static void CFunc_AutoResultCheck(ENode *expr) {
+    while (1) {
+        while (ENODE_IS(expr, ECOMMA))
+            expr = expr->data.diadic.right;
+
+        switch (expr->type) {
+            case EOBJREF:
+                if (expr->data.objref->datatype != DLOCAL)
+                    break;
+            case ETEMP:
+                CError_Warning(CErrorStr326);
+                break;
+            case EADD:
+            case ESUB:
+                CFunc_AutoResultCheck(expr->data.diadic.left);
+                expr = expr->data.diadic.right;
+                continue;
+            default:
+                break;
+        }
+        break;
+    }
+}
+
+static void statement(DeclThing *thing) {
+    Statement *stmt;
+    Statement *stmt2;
+    CLabel *label;
+    DeclBlock *block;
+    ENode *expr;
+    HashNameNode *name;
+    DeclThing subthing;
+
+    CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+
+    switch (tk) {
+        case TK_RETURN:
+            tk = lex();
+            if (
+                (thing->thetype == &stvoid && !copts.cplusplus) ||
+                CClass_IsConstructor(cscope_currentfunc) ||
+                CClass_IsDestructor(cscope_currentfunc)
+                )
+            {
+                if (tk != ';') {
+                    CError_Error(CErrorStr315);
+                    expression();
+                }
+
+                stmt = CFunc_AppendStatement(ST_RETURN);
+                stmt->expr = NULL;
+                CError_ResetErrorSkip();
+                tk = lex();
+                return;
+            }
+
+            if (tk == ';') {
+                if (thing->thetype != &stvoid && (copts.pedantic || copts.cplusplus))
+                    CError_Warning(CErrorStr184);
+
+                stmt = CFunc_AppendStatement(ST_RETURN);
+                stmt->expr = NULL;
+                CError_ResetErrorSkip();
+                tk = lex();
+                return;
+            }
+
+            if (copts.old_argmatch)
+                expr = expression();
+            else
+                expr = s_expression();
+
+            if (thing->thetype == &stvoid) {
+                if (expr->rtype != &stvoid)
+                    CError_Error(CErrorStr315);
+
+                stmt = CFunc_AppendStatement(ST_EXPRESSION);
+                stmt->expr = expr;
+
+                stmt = CFunc_AppendStatement(ST_RETURN);
+                stmt->expr = NULL;
+            } else {
+                if (CMach_GetFunctionResultClass(TYPE_FUNC(cscope_currentfunc->type)) == 1)
+                    expr = returnstatementadjust(expr, thing->thetype, thing->qual);
+                else
+                    expr = CExpr_AssignmentPromotion(expr, thing->thetype, thing->qual, 1);
+
+                stmt = CFunc_AppendStatement(ST_RETURN);
+                stmt->expr = expr;
+
+                if (IS_TYPE_POINTER_ONLY(thing->thetype))
+                    CFunc_AutoResultCheck(expr);
+            }
+
+            break;
+
+        case TK_CASE:
+            scancase(thing);
+            return;
+
+        case TK_DEFAULT:
+            if (!thing->switchinfo) {
+                CError_Error(CErrorStr169);
+                return;
+            }
+
+            if (lex() != ':')
+                CError_ErrorSkip(CErrorStr170);
+            else
+                tk = lex();
+
+            if (thing->switchinfo->defaultlabel)
+                CError_ErrorSkip(CErrorStr173);
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = newlabel();
+            stmt->label->stmt = stmt;
+            thing->switchinfo->defaultlabel = stmt->label;
+            statement(thing);
+            return;
+
+        case TK_SWITCH:
+            if (lex() != '(')
+                CError_ErrorSkip(CErrorStr114);
+            else
+                tk = lex();
+
+            if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+                block = CFunc_NewDeclBlock();
+                expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+                if (CScope_IsEmptyNameSpace(cscope_current)) {
+                    CFunc_RestoreBlock(block);
+                    block = NULL;
+                }
+            } else {
+                expr = expression();
+                block = NULL;
+            }
+
+            stmt = CFunc_AppendStatement(ST_SWITCH);
+            stmt->expr = CExpr_ConvertToIntegral(expr);
+
+            if (tk != ')')
+                CError_ErrorSkip(CErrorStr115);
+            else
+                tk = lex();
+
+            stmt->label = (CLabel *) lalloc(sizeof(SwitchInfo));
+            ((SwitchInfo *) stmt->label)->defaultlabel = NULL;
+            ((SwitchInfo *) stmt->label)->cases = NULL;
+            ((SwitchInfo *) stmt->label)->x8 = stmt->expr->rtype;
+
+            label = newlabel();
+            subthing = *thing;
+            subthing.loopBreak = label;
+            subthing.switchinfo = (SwitchInfo *) stmt->label;
+            CFunc_CompoundStatement(&subthing);
+
+            if (!subthing.switchinfo->defaultlabel)
+                subthing.switchinfo->defaultlabel = label;
+
+            if (!subthing.switchinfo->cases) {
+                stmt->type = ST_EXPRESSION;
+                stmt2 = lalloc(sizeof(Statement));
+                *stmt2 = *stmt;
+                stmt->next = stmt2;
+                stmt2->type = ST_GOTO;
+                stmt2->label = subthing.switchinfo->defaultlabel;
+                stmt2->dobjstack = cexcept_dobjstack;
+            }
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label;
+            label->stmt = stmt;
+
+            if (block)
+                CFunc_RestoreBlock(block);
+            return;
+
+        case TK_GOTO:
+            if ((tk = lex()) != TK_IDENTIFIER) {
+                if (tk == '*' && !copts.ANSI_strict) {
+                    tk = lex();
+                    stmt = CFunc_AppendStatement(ST_GOTOEXPR);
+                    stmt->expr = expression();
+                    if (!IS_TYPE_POINTER_ONLY(stmt->expr->rtype)) {
+                        CError_Error(CErrorStr146);
+                        stmt->expr = nullnode();
+                        stmt->expr->rtype = TYPE(&void_ptr);
+                    }
+                } else {
+                    CError_Error(CErrorStr107);
+                    return;
+                }
+            } else {
+                stmt = CFunc_AppendStatement(ST_GOTO);
+                if (!(stmt->label = findlabel())) {
+                    stmt->label = newlabel();
+                    stmt->label->next = Labels;
+                    Labels = stmt->label;
+                    stmt->label->name = tkidentifier;
+                }
+                tk = lex();
+            }
+            break;
+
+        case TK_BREAK:
+            if (thing->loopBreak) {
+                stmt = CFunc_AppendStatement(ST_GOTO);
+                stmt->label = thing->loopBreak;
+            } else {
+                CError_Error(CErrorStr169);
+            }
+            tk = lex();
+            break;
+
+        case TK_CONTINUE:
+            if (thing->loopContinue) {
+                stmt = CFunc_AppendStatement(ST_GOTO);
+                stmt->label = thing->loopContinue;
+            } else {
+                CError_Error(CErrorStr169);
+            }
+            tk = lex();
+            break;
+
+        case TK_FOR: {
+            CLabel *forLabel1;
+            CLabel *forLabel2;
+            CLabel *forLabel3;
+            ENode *forCond;
+            ENode *forInc;
+
+            if (lex() != '(')
+                CError_ErrorSkip(CErrorStr114);
+            else
+                tk = lex();
+
+            block = NULL;
+            if (tk != ';') {
+                if (!copts.cplusplus || !isdeclaration(1, 0, 0, 0)) {
+                    expr = expression();
+                    CExpr_CheckUnusedExpression(expr);
+                } else {
+                    if (!copts.ARM_scoping)
+                        block = CFunc_NewDeclBlock();
+                    expr = CFunc_ParseLocalDeclarationList(0, 1, 1, 0);
+                    if (block && CScope_IsEmptyNameSpace(cscope_current)) {
+                        CFunc_RestoreBlock(block);
+                        block = NULL;
+                    }
+                }
+
+                if (expr) {
+                    stmt = CFunc_AppendStatement(ST_EXPRESSION);
+                    stmt->expr = expr;
+                }
+
+                if (tk == ';')
+                    CError_ResetErrorSkip();
+                else
+                    CError_Error(CErrorStr123);
+            } else {
+                CError_ResetErrorSkip();
+            }
+
+            if ((tk = lex()) != ';') {
+                if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+                    if (!block)
+                        block = CFunc_NewDeclBlock();
+                    expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+                    if (CScope_IsEmptyNameSpace(cscope_current)) {
+                        CFunc_RestoreBlock(block);
+                        block = NULL;
+                    }
+                } else {
+                    expr = expression();
+                    CExpr_CheckUnwantedAssignment(expr);
+                }
+
+                forCond = CExpr_ConvertToCondition(expr);
+
+                if (tk == ';')
+                    CError_ResetErrorSkip();
+                else
+                    CError_Error(CErrorStr123);
+            } else {
+                CError_ResetErrorSkip();
+                forCond = NULL;
+            }
+
+            if ((tk = lex()) != ')') {
+                forInc = expression();
+                CExpr_CheckUnusedExpression(forInc);
+                if (tk == ')')
+                    CError_ResetErrorSkip();
+                else
+                    CError_Error(CErrorStr115);
+            } else {
+                CError_ResetErrorSkip();
+                forInc = NULL;
+            }
+
+            if (copts.warn_possunwant) {
+                spaceskip = 0;
+                if ((tk = lex()) == ';' && !spaceskip)
+                    CError_Warning(CErrorStr206);
+            } else {
+                tk = lex();
+            }
+
+            if (forCond) {
+                stmt = CFunc_AppendStatement(ST_GOTO);
+                label = newlabel();
+                stmt->label = label;
+            } else {
+                label = newlabel();
+            }
+
+            CFunc_LoopIncrement();
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            forLabel1 = stmt->label = newlabel();
+            forLabel1->stmt = stmt;
+
+            forLabel2 = newlabel();
+            forLabel3 = newlabel();
+
+            subthing = *thing;
+            subthing.loopContinue = forLabel3;
+            subthing.loopBreak = forLabel2;
+
+            if (tk != '{') {
+                DeclBlock *b = CFunc_NewDeclBlock();
+                CFunc_CompoundStatement(&subthing);
+                CFunc_RestoreBlock(b);
+            } else {
+                CFunc_CompoundStatement(&subthing);
+            }
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = forLabel3;
+            forLabel3->stmt = stmt;
+
+            if (forInc) {
+                stmt = CFunc_AppendStatement(ST_EXPRESSION);
+                stmt->expr = forInc;
+            }
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label;
+            label->stmt = stmt;
+
+            ifstatement(1, forCond, forLabel1, 1);
+            CFunc_LoopDecrement();
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = forLabel2;
+            forLabel2->stmt = stmt;
+
+            if (block)
+                CFunc_RestoreBlock(block);
+
+            return;
+        }
+
+        case TK_DO: {
+            CLabel *label1;
+            CLabel *label2;
+            CLabel *label3;
+
+            CFunc_LoopIncrement();
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            label1 = stmt->label = newlabel();
+            label1->stmt = stmt;
+
+            label2 = newlabel();
+            label3 = newlabel();
+
+            subthing = *thing;
+            subthing.loopContinue = label2;
+            subthing.loopBreak = label3;
+
+            tk = lex();
+            CFunc_CompoundStatement(&subthing);
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label2;
+            label2->stmt = stmt;
+
+            if (tk != TK_WHILE)
+                CError_Error(CErrorStr105);
+
+            if (lex() != '(')
+                CError_ErrorSkip(CErrorStr114);
+            else
+                tk = lex();
+
+            expr = CExpr_ConvertToCondition(expression());
+            CExpr_CheckUnwantedAssignment(expr);
+
+            if (tk != ')')
+                CError_ErrorSkip(CErrorStr115);
+            else
+                tk = lex();
+
+            ifstatement(1, expr, label1, 1);
+
+            CFunc_LoopDecrement();
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label3;
+            label3->stmt = stmt;
+            break;
+        }
+
+        case TK_WHILE: {
+            CLabel *label1;
+            CLabel *label2;
+            CLabel *label3;
+
+            if ((tk = lex()) != '(')
+                CError_ErrorSkip(CErrorStr114);
+            else
+                tk = lex();
+
+            if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+                block = CFunc_NewDeclBlock();
+                expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+                if (CScope_IsEmptyNameSpace(cscope_current)) {
+                    CFunc_RestoreBlock(block);
+                    block = NULL;
+                }
+            } else {
+                expr = expression();
+                block = NULL;
+                CExpr_CheckUnwantedAssignment(expr);
+            }
+            expr = CExpr_ConvertToCondition(expr);
+
+            if (tk != ')') {
+                CError_ErrorSkip(CErrorStr115);
+            } else {
+                if (copts.warn_possunwant) {
+                    spaceskip = 0;
+                    if ((tk = lex()) == ';' && !spaceskip)
+                        CError_Warning(CErrorStr206);
+                } else {
+                    tk = lex();
+                }
+            }
+
+            stmt = CFunc_AppendStatement(ST_GOTO);
+            label1 = newlabel();
+            stmt->label = label1;
+
+            CFunc_LoopIncrement();
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            label2 = stmt->label = newlabel();
+            label2->stmt = stmt;
+
+            label3 = newlabel();
+
+            subthing = *thing;
+            subthing.loopContinue = label1;
+            subthing.loopBreak = label3;
+
+            CFunc_CompoundStatement(&subthing);
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label1;
+            label1->stmt = stmt;
+
+            ifstatement(1, expr, label2, 1);
+
+            CFunc_LoopDecrement();
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label3;
+            label3->stmt = stmt;
+
+            if (block)
+                CFunc_RestoreBlock(block);
+            return;
+        }
+
+        case TK_IF: {
+            CLabel *label1;
+            if ((tk = lex()) != '(')
+                CError_ErrorSkip(CErrorStr114);
+            else
+                tk = lex();
+
+            if (copts.cplusplus && !copts.ARM_scoping && isdeclaration(1, 0, 0, '=')) {
+                block = CFunc_NewDeclBlock();
+                expr = CFunc_ParseLocalDeclarationList(0, 1, 0, 0);
+                if (CScope_IsEmptyNameSpace(cscope_current)) {
+                    CFunc_RestoreBlock(block);
+                    block = NULL;
+                }
+            } else {
+                expr = expression();
+                block = NULL;
+                CExpr_CheckUnwantedAssignment(expr);
+            }
+
+            expr = CExpr_ConvertToCondition(expr);
+
+            label1 = newlabel();
+            ifstatement(0, expr, label1, 0);
+
+            if (tk != ')') {
+                CError_ErrorSkip(CErrorStr115);
+            } else {
+                if (copts.warn_possunwant) {
+                    spaceskip = 0;
+                    if ((tk = lex()) == ';' && !spaceskip)
+                        CError_Warning(CErrorStr206);
+                } else {
+                    tk = lex();
+                }
+            }
+
+            CFunc_CompoundStatement(thing);
+
+            if (tk == TK_ELSE) {
+                if (copts.warn_possunwant) {
+                    spaceskip = 0;
+                    if ((tk = lex()) == ';' && !spaceskip)
+                        CError_Warning(CErrorStr206);
+                } else {
+                    tk = lex();
+                }
+
+                stmt = CFunc_AppendStatement(ST_GOTO);
+                label = stmt->label = newlabel();
+
+                stmt = CFunc_AppendStatement(ST_LABEL);
+                stmt->label = label1;
+                label1->stmt = stmt;
+
+                CFunc_CompoundStatement(thing);
+
+                label1 = label;
+            }
+
+            stmt = CFunc_AppendStatement(ST_LABEL);
+            stmt->label = label1;
+            label1->stmt = stmt;
+
+            if (block)
+                CFunc_RestoreBlock(block);
+
+            return;
+        }
+
+        case '{':
+            CFunc_CompoundStatement(thing);
+            return;
+
+        case TK_ASM:
+            if (copts.cplusplus || !copts.ANSI_strict) {
+                tk = lex();
+                volatileasm = 0;
+
+                if (tk == TK_VOLATILE || (tk == TK_IDENTIFIER && !strcmp(tkidentifier->name, "__volatile__"))) {
+                    tk = lex();
+                    volatileasm = 1;
+                }
+
+                if (tk == '(') {
+                    InlineAsm_Assemble();
+                    if (tk == ')') {
+                        tk = lex();
+                        break;
+                    } else {
+                        CError_Error(CErrorStr115);
+                        return;
+                    }
+                }
+
+                if (tk == '{') {
+                    InlineAsm_Assemble();
+                    if (tk != '}') {
+                        CError_Error(CErrorStr130);
+                        return;
+                    }
+                    if ((tk = lex()) == ';')
+                        tk = lex();
+                    CError_ResetErrorSkip();
+                    return;
+                }
+
+                CError_Error(CErrorStr114);
+            } else {
+                CError_Error(CErrorStr121);
+            }
+            return;
+
+        case TK_TRY:
+            tk = lex();
+            CExcept_ScanTryBlock(thing, 0);
+            return;
+
+        case TK_USING:
+            if ((tk = lex()) == TK_NAMESPACE) {
+                tk = lex();
+                CScope_ParseUsingDirective(cscope_current);
+            } else {
+                CScope_ParseUsingDeclaration(cscope_current, 0, 0);
+            }
+            return;
+
+        case TK_NAMESPACE:
+            if ((tk = lex()) != TK_IDENTIFIER) {
+                CError_Error(CErrorStr107);
+                return;
+            }
+            name = tkidentifier;
+            if ((tk = lex()) != '=') {
+                CError_Error(CErrorStr121);
+                return;
+            }
+
+            CScope_ParseNameSpaceAlias(name);
+            break;
+
+        case ';':
+            break;
+
+        case TK_IDENTIFIER:
+            if (checklabel()) {
+                stmt = CFunc_AppendStatement(ST_LABEL);
+                if ((stmt->label = findlabel())) {
+                    if (stmt->label->stmt)
+                        CError_Error(CErrorStr171, tkidentifier->name);
+                } else {
+                    stmt->label = newlabel();
+                    stmt->label->next = Labels;
+                    Labels = stmt->label;
+                    stmt->label->name = tkidentifier;
+                }
+
+                stmt->label->stmt = stmt;
+                tk = lex();
+                tk = lex();
+                statement(thing);
+                return;
+            }
+            tk = TK_IDENTIFIER;
+
+        default:
+            if (copts.cplusplus && isdeclaration(1, 0, 0, 0)) {
+                CFunc_ParseLocalDeclarationList(0, 0, 0, 1);
+                tk = lex();
+                return;
+            }
+
+            stmt = CFunc_AppendStatement(ST_EXPRESSION);
+            stmt->expr = expression();
+            CExpr_CheckUnusedExpression(stmt->expr);
+    }
+
+    if (tk == ';') {
+        CPrep_TokenStreamFlush();
+        tk = lex();
+        CError_ResetErrorSkip();
+    } else {
+        CError_ErrorSkip(CErrorStr123);
+    }
+}
+
+void CFunc_CompoundStatement(DeclThing *thing) {
+    DeclBlock *block;
+
+    block = CFunc_NewDeclBlock();
+
+    if (tk == '{') {
+        tk = lex();
+        if (!copts.cplusplus && isdeclaration(0, 0, 0, 0))
+            CFunc_ParseLocalDeclarationList(0, 0, 0, 0);
+
+        while (tk != '}')
+            statement(thing);
+
+        CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+        tk = lex();
+    } else {
+        statement(thing);
+    }
+
+    CFunc_RestoreBlock(block);
+}
+
+static void CFunc_InsertArgumentCopyConversion(Object *obj, Type *type1, Type *type2, Boolean flag) {
+    Object *newobj;
+    Statement *stmt;
+    ENode *expr;
+    NameSpaceObjectList *nsol;
+    ObjectList *list;
+
+    newobj = lalloc(sizeof(Object));
+    *newobj = *obj;
+    newobj->type = type2;
+
+    CFunc_SetupLocalVarInfo(newobj);
+
+    obj->name = CParser_GetUniqueName();
+    if (flag)
+        obj->type = CDecl_NewPointerType(type1);
+    else
+        obj->type = type1;
+
+    CError_ASSERT(2527, (nsol = CScope_FindName(cscope_current, newobj->name)) && nsol->object == OBJ_BASE(obj));
+    nsol->object = OBJ_BASE(newobj);
+
+    list = lalloc(sizeof(ObjectList));
+    list->object = newobj;
+    list->next = locals;
+    locals = list;
+
+    stmt = CFunc_AppendStatement(ST_EXPRESSION);
+    expr = create_objectnode(obj);
+    if (flag) {
+        expr->rtype = CDecl_NewPointerType(type1);
+        expr = makemonadicnode(expr, EINDIRECT);
+    }
+    expr->rtype = type1;
+
+    if (type1 != type2)
+        expr = promote(expr, type2);
+
+    stmt->expr = makediadicnode(create_objectnode(newobj), expr, EASS);
+}
+
+static void CFunc_AdjustOldStyleArgs(void) {
+    ObjectList *list;
+
+    for (list = arguments; list; list = list->next) {
+        if (IS_TYPE_FLOAT(list->object->type) && list->object->type->size < stdouble.size)
+            CFunc_InsertArgumentCopyConversion(list->object, TYPE(&stdouble), list->object->type, 0);
+    }
+}
+
+void CFunc_SetupNewFuncArgs(Object *func, FuncArg *args) {
+    Object *obj;
+    ObjectList *newlist;
+
+    arguments = NULL;
+
+    if (args != &elipsis && args != &oldstyle) {
+        newlist = NULL;
+
+        while (args && args != &elipsis) {
+            IsCompleteType(args->type);
+
+            obj = CParser_NewLocalDataObject(NULL, 0);
+            obj->name = !args->name ? no_name_node : args->name;
+            obj->type = args->type;
+            obj->qual = args->qual;
+            obj->sclass = args->sclass;
+
+            CFunc_SetupLocalVarInfo(obj);
+
+            if (IS_TYPE_CLASS(obj->type) && CClass_ReferenceArgument(TYPE_CLASS(obj->type))) {
+                obj->type = CDecl_NewPointerType(obj->type);
+                TPTR_QUAL(obj->type) = Q_REFERENCE | Q_RESTRICT;
+            }
+
+            if (obj->name == no_name_node && copts.ANSI_strict && !copts.cplusplus && !(func->qual & Q_80000))
+                CError_Error(CErrorStr127);
+
+            if (newlist) {
+                newlist->next = lalloc(sizeof(ObjectList));
+                newlist = newlist->next;
+            } else {
+                newlist = lalloc(sizeof(ObjectList));
+                arguments = newlist;
+            }
+
+            newlist->next = NULL;
+            newlist->object = obj;
+
+            args = args->next;
+        }
+    }
+}
+
+static ObjectList *CFunc_CopyObjectList(const FuncArg *args) {
+    Object *obj;
+    ObjectList *list;
+    ObjectList *last;
+
+    list = NULL;
+
+    while (args) {
+        if (list) {
+            last->next = lalloc(sizeof(ObjectList));
+            last = last->next;
+        } else {
+            last = lalloc(sizeof(ObjectList));
+            list = last;
+        }
+
+        obj = CParser_NewLocalDataObject(NULL, 0);
+        obj->name = args->name;
+        obj->type = args->type;
+        obj->qual = args->qual;
+        obj->sclass = args->sclass;
+        CFunc_SetupLocalVarInfo(obj);
+
+        last->object = obj;
+        last->next = NULL;
+
+        args = args->next;
+    }
+
+    return list;
+}
+
+static void SetupFunctionArguments(Object *func, DeclInfo *di, Statement *firstStmt) {
+    ObjectList *list;
+    Object *resultobj;
+    Object *obj;
+    Type *type;
+    DeclInfo my_di;
+
+    if (TYPE_FUNC(func->type)->args) {
+        if (di->x45) {
+            arguments = CFunc_CopyObjectList(di->x18);
+            while (1) {
+                if (tk == '{')
+                    break;
+
+                memclrw(&my_di, sizeof(my_di));
+                CParser_GetDeclSpecs(&my_di, 0);
+
+                type = my_di.thetype;
+                if (my_di.storageclass && my_di.storageclass != TK_REGISTER)
+                    CError_Error(CErrorStr127);
+
+                while (1) {
+                    my_di.thetype = type;
+                    my_di.name = NULL;
+                    scandeclarator(&my_di);
+                    if (!my_di.name) {
+                        CError_Error(CErrorStr107);
+                        break;
+                    }
+
+                    adjustargumenttype(&my_di);
+                    IsCompleteType(my_di.thetype);
+
+                    if ((obj = CFunc_IsInObjList(arguments, my_di.name))) {
+                        if (obj->type)
+                            CError_Error(CErrorStr333, obj);
+                        obj->type = my_di.thetype;
+                        obj->sclass = my_di.storageclass;
+                        obj->qual = my_di.qual;
+                    } else {
+                        CError_Error(CErrorStr127);
+                    }
+
+                    if (tk != ',')
+                        break;
+                    tk = lex();
+                }
+
+                if (tk != ';')
+                    CError_ErrorSkip(CErrorStr123);
+                else
+                    tk = lex();
+            }
+
+            for (list = arguments; list; list = list->next) {
+                if (!list->object->type)
+                    list->object->type = TYPE(&stsignedint);
+            }
+        } else {
+            CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+        }
+    }
+
+    if (CMach_GetFunctionResultClass(TYPE_FUNC(func->type)) == 1) {
+        resultobj = CParser_NewLocalDataObject(NULL, 0);
+        resultobj->name = temp_argument_name;
+        resultobj->type = CDecl_NewPointerType(TYPE_FUNC(func->type)->functype);
+        CFunc_SetupLocalVarInfo(resultobj);
+
+        list = lalloc(sizeof(ObjectList));
+        list->object = resultobj;
+        if (CABI_GetStructResultArgumentIndex(TYPE_FUNC(func->type))) {
+            CError_ASSERT(2797, arguments);
+            list->next = arguments->next;
+            arguments->next = list;
+        } else {
+            list->next = arguments;
+            arguments = list;
+        }
+    }
+
+    for (list = arguments; list; list = list->next) {
+        NameSpaceObjectList *nsol = CScope_InsertName(cscope_current, list->object->name);
+        nsol->object = OBJ_BASE(list->object);
+    }
+}
+
+NameSpace *CFunc_FuncGenSetup(Statement *stmt, Object *func) {
+    NameSpace *nspace;
+    DeclBlock *block;
+
+    nspace = CScope_NewListNameSpace(NULL, 0);
+    nspace->parent = cscope_current;
+    cscope_current = nspace;
+
+    arguments = NULL;
+    locals = NULL;
+    Labels = NULL;
+
+    localcount = 0;
+    cfunc_staticvarcount = 0;
+
+    CExcept_Setup();
+
+    memclrw(stmt, sizeof(Statement));
+    curstmt = stmt;
+    stmt->type = ST_NOP;
+    curstmtvalue = 1;
+    stmt->value = 1;
+
+    blockcount = 0;
+    block = lalloc(sizeof(DeclBlock));
+    memclrw(block, sizeof(DeclBlock));
+    block->index = blockcount++;
+    block->parent_nspace = cscope_current;
+
+    firstblock = block;
+    currentblock = block;
+
+    return nspace;
+}
+
+CFuncSave *CFunc_GetGlobalCompilerState(void) {
+    CFuncSave *state;
+
+    if (!cscope_currentfunc && !cscope_currentclass && cscope_current == cscope_root)
+        return NULL;
+
+    locklheap();
+    state = lalloc(sizeof(CFuncSave));
+
+    CScope_SetNameSpaceScope(cscope_root, &state->scope);
+
+    state->arguments = arguments;
+    arguments = NULL;
+
+    state->locals = locals;
+    locals = NULL;
+
+    state->labels = Labels;
+    Labels = NULL;
+
+    state->curstmt = curstmt;
+    curstmt = NULL;
+
+    state->firstblock = firstblock;
+    firstblock = NULL;
+
+    state->currentblock = currentblock;
+    currentblock = NULL;
+
+    state->cexcept_dobjstack = cexcept_dobjstack;
+    cexcept_dobjstack = NULL;
+
+    state->sinit_label = sinit_label;
+    sinit_label = NULL;
+
+    state->ainit_expr = ainit_expr;
+    ainit_expr = NULL;
+
+    state->ctor_chain = ctor_chain;
+    ctor_chain = NULL;
+
+    state->cinit_tempnodefunc = cinit_tempnodefunc;
+    cinit_tempnodefunc = NULL;
+
+    state->trychain = trychain;
+    trychain = NULL;
+
+    state->cparser_fileoffset = cparser_fileoffset;
+    state->symdecltoken = symdecltoken;
+
+    state->functionbodyoffset = functionbodyoffset;
+    functionbodyoffset = 0;
+
+    state->functionbodypath = functionbodypath;
+    functionbodypath = NULL;
+
+    state->symdecloffset = symdecloffset;
+    symdecloffset = 0;
+
+    state->symdeclend = symdeclend;
+
+    state->sourceoffset = sourceoffset;
+    sourceoffset = 0;
+
+    state->sourcefilepath = sourcefilepath;
+    sourcefilepath = NULL;
+
+    state->curstmtvalue = curstmtvalue;
+    curstmtvalue = 0;
+
+    state->name_obj_check = name_obj_check;
+    name_obj_check = NULL;
+
+    state->check_arglist = check_arglist;
+    check_arglist = NULL;
+
+    state->blockcount = blockcount;
+    blockcount = 0;
+
+    state->localcount = localcount;
+    localcount = 0;
+
+    state->tk = tk;
+    state->tkidentifier = tkidentifier;
+
+    state->global_access = global_access;
+
+    state->cexcept_hasdobjects = cexcept_hasdobjects;
+    cexcept_hasdobjects = 0;
+
+    state->sinit_first_object = sinit_first_object;
+    sinit_first_object = NULL;
+
+    state->ainit_only_one = ainit_only_one;
+    ainit_only_one = 0;
+
+    state->cfunc_is_extern_c = cfunc_is_extern_c;
+    cfunc_is_extern_c = 0;
+
+    state->temp_reference_init = temp_reference_init;
+
+    return state;
+}
+
+void CFunc_SetGlobalCompilerState(CFuncSave *state) {
+    if (state) {
+        CScope_RestoreScope(&state->scope);
+
+        arguments = state->arguments;
+        locals = state->locals;
+        Labels = state->labels;
+        curstmt = state->curstmt;
+        firstblock = state->firstblock;
+        currentblock = state->currentblock;
+        cexcept_dobjstack = state->cexcept_dobjstack;
+        sinit_label = state->sinit_label;
+        ainit_expr = state->ainit_expr;
+        ctor_chain = state->ctor_chain;
+        cinit_tempnodefunc = state->cinit_tempnodefunc;
+        trychain = state->trychain;
+        name_obj_check = state->name_obj_check;
+        check_arglist = state->check_arglist;
+        curstmtvalue = state->curstmtvalue;
+        cparser_fileoffset = state->cparser_fileoffset;
+        symdecltoken = state->symdecltoken;
+        functionbodyoffset = state->functionbodyoffset;
+        functionbodypath = state->functionbodypath;
+        symdecloffset = state->symdecloffset;
+        symdeclend = state->symdeclend;
+        sourceoffset = state->sourceoffset;
+        sourcefilepath = state->sourcefilepath;
+        blockcount = state->blockcount;
+        tk = state->tk;
+        tkidentifier = state->tkidentifier;
+        global_access = state->global_access;
+        localcount = state->localcount;
+        cexcept_hasdobjects = state->cexcept_hasdobjects;
+        sinit_first_object = state->sinit_first_object;
+        ainit_only_one = state->ainit_only_one;
+        cfunc_is_extern_c = state->cfunc_is_extern_c;
+        temp_reference_init = state->temp_reference_init;
+
+        unlocklheap();
+    }
+}
+
+void CFunc_Gen(Statement *stmt, Object *func, UInt8 unk) {
+    Boolean flag;
+    CI_FuncData packed;
+
+    if ((TYPE_FUNC(func->type)->flags & FUNC_FLAGS_400000) && !anyerrors) {
+        CInline_PackIFunctionData(&packed, stmt, func);
+        flag = 1;
+    } else {
+        flag = 0;
+    }
+
+    CInline_GenFunc(stmt, func, unk);
+
+    if (flag)
+        CClass_DefineCovariantFuncs(func, &packed);
+}
+
+static void CFunc_CheckCtorInitializer(TypeClass *tclass, CtorChain *chain) {
+    ObjMemberVar *ivar;
+    CtorChain *scan;
+
+    if (tclass->mode != CLASS_MODE_1) {
+        for (ivar = tclass->ivars; ivar; ivar = ivar->next) {
+            if (IS_TYPE_REFERENCE(ivar->type)) {
+                for (scan = chain; scan; scan = scan->next) {
+                    if (scan->what == CtorChain_MemberVar && scan->u.membervar == ivar)
+                        break;
+                }
+
+                if (!scan)
+                    CError_Error(CErrorStr256, ivar->name->name);
+            } else if (CParser_IsConst(ivar->type, ivar->qual)) {
+                for (scan = chain; scan; scan = scan->next) {
+                    if (scan->what == CtorChain_MemberVar && scan->u.membervar == ivar)
+                        break;
+                }
+
+                if (!scan && !IS_TYPE_CLASS(ivar->type))
+                    CError_Error(CErrorStr255, ivar->name->name);
+            }
+        }
+    }
+}
+
+void CFunc_CheckClassCtors(TypeClass *tclass) {
+    CFunc_CheckCtorInitializer(tclass, NULL);
+}
+
+static void CFunc_ParseCtorInitializer(void) {
+    CtorChain *chain;
+    ENodeList *args;
+    TypeClass *tclass;
+    ObjMemberVar *ivar;
+    ClassList *base;
+    VClassList *vbase;
+    ENode *expr;
+    Type *origtype;
+
+    ctor_chain = NULL;
+
+    if (tk == ':') {
+        do {
+            tclass = NULL;
+            switch ((tk = lex())) {
+                case TK_IDENTIFIER:
+                    for (ivar = cscope_currentclass->ivars; ivar; ivar = ivar->next) {
+                        if (ivar->name == tkidentifier && lookahead() == '(')
+                            goto do_ivar;
+                    }
+                    for (base = cscope_currentclass->bases; base; base = base->next) {
+                        if (base->base->classname == tkidentifier) {
+                            if (lookahead() == '(') {
+                                tclass = base->base;
+                                tk = lex();
+                            } else {
+                                tkidentifier = base->base->classname;
+                            }
+                            break;
+                        }
+                    }
+                    break;
+
+                case TK_COLON_COLON:
+                    break;
+
+                default:
+                    CError_Error(CErrorStr212);
+                    return;
+            }
+
+            if (!tclass)
+                tclass = CClass_GetQualifiedClass();
+
+            if (tclass) {
+                for (vbase = cscope_currentclass->vbases; vbase; vbase = vbase->next) {
+                    if (vbase->base == tclass)
+                        break;
+                }
+
+                if (vbase) {
+                    for (chain = ctor_chain; chain; chain = chain->next) {
+                        if (chain->what == CtorChain_VBase && chain->u.vbase == vbase) {
+                            CError_Error(CErrorStr212);
+                            return;
+                        }
+                    }
+
+                    chain = lalloc(sizeof(CtorChain));
+                    chain->what = CtorChain_VBase;
+                    chain->u.vbase = vbase;
+                } else {
+                    for (base = cscope_currentclass->bases; base; base = base->next) {
+                        if (base->base == tclass)
+                            break;
+                    }
+
+                    if (base) {
+                        for (chain = ctor_chain; chain; chain = chain->next) {
+                            if (chain->what == CtorChain_Base && chain->u.base == base) {
+                                CError_Error(CErrorStr212);
+                                return;
+                            }
+                        }
+
+                        chain = lalloc(sizeof(CtorChain));
+                        chain->what = CtorChain_Base;
+                        chain->u.base = base;
+                    } else {
+                        CError_Error(CErrorStr212);
+                        return;
+                    }
+                }
+            } else {
+                for (ivar = cscope_currentclass->ivars; ivar; ivar = ivar->next) {
+                    if (ivar->name == tkidentifier)
+                        break;
+                }
+
+                if (ivar) {
+                do_ivar:
+                    for (chain = ctor_chain; chain; chain = chain->next) {
+                        if (chain->what == CtorChain_MemberVar && chain->u.membervar == ivar)
+                            CError_Error(CErrorStr212);
+                    }
+
+                    chain = lalloc(sizeof(CtorChain));
+                    chain->what = CtorChain_MemberVar;
+                    chain->u.membervar = ivar;
+                } else {
+                    CError_Error(CErrorStr212);
+                    return;
+                }
+
+                tk = lex();
+            }
+
+            if (tk != '(') {
+                CError_Error(CErrorStr114);
+                return;
+            }
+
+            tk = lex();
+            args = CExpr_ScanExpressionList(1);
+
+            if (tk != ')') {
+                CError_Error(CErrorStr115);
+                return;
+            }
+
+            switch (chain->what) {
+                case CtorChain_Base:
+                    expr = CABI_MakeThisExpr(NULL, chain->u.base->offset);
+                    chain->objexpr = CExpr_ConstructObject(chain->u.base->base, expr, args, 1, 0, 0, 0, 1);
+                    break;
+                case CtorChain_VBase:
+                    expr = CABI_MakeThisExpr(chain->u.vbase->base, chain->u.vbase->offset);
+                    chain->objexpr = CExpr_ConstructObject(chain->u.vbase->base, expr, args, 1, 0, 0, 0, 1);
+                    break;
+                case CtorChain_MemberVar:
+                    expr = CABI_MakeThisExpr(cscope_currentclass, chain->u.membervar->offset);
+                    expr->flags = chain->u.membervar->qual & ENODE_FLAG_QUALS;
+                    switch (chain->u.membervar->type->type) {
+                        case TYPECLASS:
+                            chain->objexpr = CExpr_ConstructObject(TYPE_CLASS(chain->u.membervar->type), expr, args, 1, 1, 0, 1, 1);
+                            break;
+                        case TYPEARRAY:
+                            if (args) {
+                                CError_Error(CErrorStr212);
+                                continue;
+                            }
+                            chain->objexpr = NULL;
+                            break;
+                        default:
+                            if (!args) {
+                                args = lalloc(sizeof(ENodeList));
+                                args->next = NULL;
+                                args->node = CExpr_DoExplicitConversion(chain->u.membervar->type, chain->u.membervar->qual, NULL);
+                            }
+                            if (args->next) {
+                                CError_Error(CErrorStr212);
+                                return;
+                            }
+                            expr = makemonadicnode(expr, EINDIRECT);
+                            expr->rtype = chain->u.membervar->type;
+                            if (IS_TYPE_BITFIELD(origtype = expr->rtype)) {
+                                expr->data.monadic = makemonadicnode(expr->data.monadic, EBITFIELD);
+                                expr->data.monadic->rtype = origtype;
+                                expr->rtype = TYPE_BITFIELD(origtype)->bitfieldtype;
+                            }
+
+                            chain->objexpr = makediadicnode(expr, CExpr_AssignmentPromotion(args->node, expr->rtype, expr->flags, 1), EASS);
+                    }
+                    break;
+                default:
+                    CError_FATAL(3286);
+            }
+
+            chain->next = ctor_chain;
+            ctor_chain = chain;
+        } while ((tk = lex()) == ',');
+    }
+}
+
+static void CFunc_FunctionRedefinedCheck(Object *func) {
+    if (TYPE_FUNC(func->type)->flags & FUNC_FLAGS_100)
+        CError_Error(CErrorStr333, func);
+
+    if ((TYPE_FUNC(func->type)->flags & FUNC_FLAGS_2) && func->datatype != DINLINEFUNC)
+        CError_Error(CErrorStr333, func);
+
+    TYPE_FUNC(func->type)->flags |= FUNC_FLAGS_2;
+}
+
+static Object *CFunc_DeclareFuncName(char *str, HashNameNode *name) {
+    Object *obj;
+    Object *aliasobj;
+    DeclInfo di;
+
+    memclrw(&di, sizeof(di));
+    di.name = name;
+    di.storageclass = TK_STATIC;
+    di.qual = Q_CONST;
+    di.thetype = CDecl_NewArrayType(TYPE(&stchar), strlen(str) + 1);
+
+    obj = CParser_NewGlobalDataObject(&di);
+    aliasobj = CParser_NewAliasObject(obj, 0);
+    obj->nspace = cscope_root;
+    obj->datatype = DDATA;
+    CFunc_NameLocalStaticDataObject(obj, obj->name->name);
+
+    return aliasobj;
+}
+
+void CFunc_ParseFuncDef(Object *func, DeclInfo *di, TypeClass *tclass, Boolean is_method, Boolean is_static, NameSpace *nspace) {
+    Boolean has_try;
+    Object *nameobj_func;
+    Object *nameobj_FUNCTION;
+    Object *nameobj_pretty;
+    char *prettyname;
+    Statement *stmt18;
+    Statement *stmt16;
+    Statement firstStmt;
+    DeclThing thing;
+    CScopeSave scope;
+
+    nameobj_func = NULL;
+    nameobj_FUNCTION = NULL;
+    nameobj_pretty = NULL;
+    prettyname = NULL;
+
+    CError_ASSERT(3373, IS_TYPE_FUNC(func->type));
+
+    CFunc_FunctionRedefinedCheck(func);
+    CParser_UpdateObject(func, di);
+
+    if (!is_method) {
+        CScope_SetFunctionScope(func, &scope);
+        if (tclass)
+            cscope_current = tclass->nspace;
+    } else {
+        CScope_SetMethodScope(func, tclass, is_static, &scope);
+    }
+
+    if (nspace)
+        cscope_current = nspace;
+
+    if (cscope_currentclass)
+        CClass_MemberDef(func, cscope_currentclass);
+
+    cfunc_is_extern_c = di->x4E;
+
+    CError_ASSERT(3392, IS_TYPE_FUNC(func->type));
+    if (di->x45 && (func->qual & Q_ASM))
+        CError_Error(CErrorStr176);
+
+    if (cparamblkptr->isPrecompiling == 1 && !(func->qual & Q_INLINE))
+        CError_ErrorTerm(CErrorStr180);
+
+    if (di->x49)
+        CError_Error(CErrorStr127);
+
+    CFunc_FuncGenSetup(&firstStmt, func);
+    if (!IS_TYPE_VOID(TYPE_FUNC(func->type)->functype))
+        IsCompleteType(TYPE_FUNC(func->type)->functype);
+
+    SetupFunctionArguments(func, di, &firstStmt);
+
+    stmt18 = curstmt;
+    CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+    functionbodyoffset = sourceoffset;
+    firstStmt.sourceoffset = sourceoffset;
+    functionbodypath = sourcefilepath;
+    firstStmt.sourcefilepath = sourcefilepath;
+
+    if (di->x45)
+        CFunc_AdjustOldStyleArgs();
+
+    if (di->x1C)
+        CScope_MergeNameSpace(cscope_current, di->x1C);
+
+    if (tk == TK_TRY) {
+        tk = lex();
+        has_try = 1;
+    } else {
+        has_try = 0;
+    }
+
+    if (CClass_IsConstructor(func)) {
+        CError_ASSERT(3445, cscope_currentclass);
+        CFunc_ParseCtorInitializer();
+        CFunc_CheckCtorInitializer(cscope_currentclass, ctor_chain);
+    }
+
+    CPrep_TokenStreamFlush();
+
+    if (!(func->qual & Q_ASM)) {
+        if (tk == '{') {
+            if (!has_try)
+                tk = lex();
+        } else {
+            CError_ErrorSkip(CErrorStr135);
+            has_try = 0;
+        }
+
+        if (func->name) {
+            nameobj_func = CFunc_DeclareFuncName(func->name->name, GetHashNameNode("__func__"));
+            nameobj_FUNCTION = CFunc_DeclareFuncName(func->name->name, GetHashNameNode("__FUNCTION__"));
+            prettyname = CError_GetObjectName(func);
+            nameobj_pretty = CFunc_DeclareFuncName(prettyname, GetHashNameNode("__PRETTY_FUNCTION__"));
+        }
+
+        if (!copts.cplusplus)
+            CFunc_ParseLocalDeclarationList(0, 0, 0, 0);
+
+        thing.switchinfo = NULL;
+        thing.loopContinue = NULL;
+        thing.loopBreak = NULL;
+        thing.thetype = TYPE_FUNC(func->type)->functype;
+        thing.qual = TYPE_FUNC(func->type)->qual;
+
+        if (has_try) {
+            CExcept_ScanTryBlock(&thing, CClass_IsConstructor(func) || CClass_IsDestructor(func));
+            if (tk != 0)
+                CPrep_UnLex();
+            tk = '}';
+        } else {
+            while (tk != '}')
+                statement(&thing);
+        }
+
+        stmt16 = curstmt;
+
+        if (stmt16->type != ST_RETURN && stmt16->type != ST_GOTO) {
+            CPrep_GetFileOffsetInfo2(&cparser_fileoffset, &sourceoffset, &sourcefilepath);
+            CFunc_AppendStatement(ST_RETURN);
+
+            curstmt->dobjstack = NULL;
+            curstmt->expr = NULL;
+
+            if (
+                (copts.cplusplus || copts.c9x) &&
+                !strcmp(func->name->name, "main") &&
+                TYPE_FUNC(func->type)->functype == TYPE(&stsignedint)
+                )
+                curstmt->expr = intconstnode(TYPE(&stsignedint), 0);
+
+            if (
+                stmt16->type == ST_EXPRESSION &&
+                stmt16->expr->type == EFUNCCALL &&
+                stmt16->expr->rtype == &stvoid &&
+                (stmt16->expr->flags & ENODE_FLAG_VOLATILE)
+                )
+                curstmt->flags |= StmtFlag_8;
+        }
+
+        CheckCLabels();
+
+        if (nameobj_func && (nameobj_func->flags & OBJECT_FLAGS_UNUSED))
+            CInit_DeclareData(nameobj_func->u.alias.object, func->name->name, NULL, strlen(func->name->name) + 1);
+        if (nameobj_FUNCTION && (nameobj_FUNCTION->flags & OBJECT_FLAGS_UNUSED))
+            CInit_DeclareData(nameobj_FUNCTION->u.alias.object, func->name->name, NULL, strlen(func->name->name) + 1);
+        if (nameobj_pretty && (nameobj_pretty->flags & OBJECT_FLAGS_UNUSED))
+            CInit_DeclareData(nameobj_pretty->u.alias.object, prettyname, NULL, strlen(prettyname) + 1);
+
+        if (!fatalerrors) {
+            if (CClass_IsConstructor(func))
+                CABI_TransConstructor(func, stmt18, cscope_currentclass, NULL, has_try);
+            if (CClass_IsDestructor(func))
+                CABI_TransDestructor(func, func, &firstStmt, cscope_currentclass, 0);
+
+            CFunc_DestructorCleanup(&firstStmt);
+            CFunc_CodeCleanup(&firstStmt);
+            symdeclend = CPrep_GetFileOffsetInfo(&cparser_fileoffset);
+            CFunc_Gen(&firstStmt, func, di->x45);
+        }
+    } else {
+        if (tk == '{') {
+            in_assembler = 1;
+            tk = lex();
+            in_assembler = 0;
+        } else {
+            CError_ErrorSkip(CErrorStr135);
+        }
+
+        CFunc_ParseLocalDeclarationList(1, 0, 0, 0);
+        Assembler(func);
+    }
+
+    if (tk != '}')
+        CError_Error(CErrorStr130);
+
+    CScope_RestoreScope(&scope);
+}
+
+void InitExpr_Register(ENode *expr, Object *object) {
+    InitExpr *initexpr;
+    InitExpr *scan;
+
+    if (
+        cparamblkptr->isPrecompiling == 1 &&
+        object->sclass != TK_STATIC &&
+        !(object->qual & (Q_20000 | Q_OVERLOAD))
+        )
+    {
+        CError_Error(CErrorStr180);
+        return;
+    }
+
+    if (copts.suppress_init_code)
+        return;
+
+    initexpr = galloc(sizeof(InitExpr));
+    initexpr->next = NULL;
+    initexpr->object = object;
+    initexpr->expr = CInline_CopyExpression(expr, CopyMode1);
+
+    if (init_expressions) {
+        scan = init_expressions;
+        while (scan->next)
+            scan = scan->next;
+        scan->next = initexpr;
+    } else {
+        init_expressions = initexpr;
+    }
+}
+
+void CFunc_GenerateDummyFunction(Object *func) {
+    NameSpace *nspace;
+    Boolean saveDebugInfo;
+    Statement firstStmt;
+
+    if (!anyerrors) {
+        nspace = CFunc_FuncGenSetup(&firstStmt, NULL);
+
+        saveDebugInfo = copts.isGeneratingDebugInfo;
+        copts.isGeneratingDebugInfo = 0;
+
+        CFunc_CodeCleanup(&firstStmt);
+        CFunc_Gen(&firstStmt, func, 0);
+
+        cscope_current = nspace->parent;
+        copts.isGeneratingDebugInfo = saveDebugInfo;
+    }
+}
+
+void CFunc_GenerateSingleExprFunc(Object *func, ENode *expr) {
+    NameSpace *nspace;
+    Boolean saveDebugInfo;
+    Statement firstStmt;
+    Statement *stmt;
+
+    if (cparamblkptr->isPrecompiling == 1) {
+        CError_Error(CErrorStr180);
+        return;
+    }
+
+    if (!anyerrors) {
+        nspace = CFunc_FuncGenSetup(&firstStmt, func);
+
+        saveDebugInfo = copts.isGeneratingDebugInfo;
+        copts.isGeneratingDebugInfo = 0;
+
+        stmt = CFunc_AppendStatement(ST_EXPRESSION);
+        stmt->expr = expr;
+
+        CFunc_CodeCleanup(&firstStmt);
+        CInline_GenFunc(&firstStmt, func, 0);
+
+        cscope_current = nspace->parent;
+        copts.isGeneratingDebugInfo = saveDebugInfo;
+    }
+}
+
+void CFunc_GenerateDummyCtorFunc(Object *func, Object *real_ctor) {
+    ENode *expr;
+    NameSpace *nspace;
+    FuncArg *arg1;
+    FuncArg *arg0;
+    ENodeList *list;
+    Boolean saveDebugInfo;
+    Statement firstStmt;
+    Statement *stmt;
+
+    if (cparamblkptr->isPrecompiling == 1) {
+        CError_Error(CErrorStr180);
+        return;
+    }
+
+    if (!anyerrors) {
+        cscope_currentfunc = func;
+
+        nspace = CFunc_FuncGenSetup(&firstStmt, func);
+
+        saveDebugInfo = copts.isGeneratingDebugInfo;
+        copts.isGeneratingDebugInfo = 0;
+
+        CFunc_SetupNewFuncArgs(func, TYPE_FUNC(func->type)->args);
+
+        expr = CExpr_NewENode(EFUNCCALL);
+        expr->type = EFUNCCALL;
+        expr->cost = 200;
+        expr->rtype = TYPE(&void_ptr);
+        expr->data.funccall.funcref = CExpr_MakeObjRefNode(real_ctor, 0);
+        expr->data.funccall.functype = TYPE_FUNC(func->type);
+
+        CError_ASSERT(3716, IS_TYPE_FUNC(real_ctor->type));
+        CError_ASSERT(3717, TYPE_FUNC(real_ctor->type)->flags & FUNC_FLAGS_METHOD);
+        CError_ASSERT(3718, arg0 = TYPE_FUNC(real_ctor->type)->args);
+        CError_ASSERT(3720, arg1 = arg0->next);
+        CError_ASSERT(3721, arguments);
+
+        list = lalloc(sizeof(ENodeList));
+        expr->data.funccall.args = list;
+        list->node = create_objectnode(arguments->object);
+
+        if (TYPE_METHOD(real_ctor->type)->theclass->flags & CLASS_FLAGS_20) {
+            CError_ASSERT(3727, arg1 = arg1->next);
+            CError_ASSERT(3728, arguments->next);
+            list->next = lalloc(sizeof(ENodeList));
+            list = list->next;
+            list->node = create_objectnode(arguments->next->object);
+        }
+
+        while (arg1) {
+            CError_ASSERT(3737, arg1->dexpr);
+            list->next = lalloc(sizeof(ENodeList));
+            list = list->next;
+            list->node = CExpr_GetDefaultArgument(expr->data.funccall.funcref, arg1);
+            arg1 = arg1->next;
+        }
+
+        list->next = NULL;
+
+        stmt = CFunc_AppendStatement(ST_RETURN);
+        stmt->expr = expr;
+
+        CFunc_CodeCleanup(&firstStmt);
+        CInline_GenFunc(&firstStmt, func, 0);
+
+        cscope_current = nspace->parent;
+        cscope_currentfunc = NULL;
+        copts.isGeneratingDebugInfo = saveDebugInfo;
+    }
+}
diff --git a/compiler_and_linker/unsorted/CInit.c b/compiler_and_linker/unsorted/CInit.c
index ccc534e..a76bdab 100644
--- a/compiler_and_linker/unsorted/CInit.c
+++ b/compiler_and_linker/unsorted/CInit.c
@@ -3,25 +3,21 @@
 #include "compiler/CClass.h"
 #include "compiler/CDecl.h"
 #include "compiler/CError.h"
+#include "compiler/CException.h"
 #include "compiler/CExpr.h"
 #include "compiler/CInline.h"
 #include "compiler/CInt64.h"
 #include "compiler/CMachine.h"
 #include "compiler/CParser.h"
+#include "compiler/CPrec.h"
 #include "compiler/CPrep.h"
 #include "compiler/CPrepTokenizer.h"
 #include "compiler/CScope.h"
 #include "compiler/CompilerTools.h"
+#include "compiler/ObjGenMachO.h"
 #include "compiler/objects.h"
 #include "compiler/types.h"
 
-// TODO - move me!!
-extern void PreComp_StaticData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void ObjGen_DeclareReadOnlyData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void ObjGen_DeclareData(Object *obj, void *data, OLinkList *list, SInt32 size);
-extern void CExcept_RegisterDestructorObject(Object *obj, SInt32 offset, Object *dtor, Boolean flag);
-extern void CExcept_RegisterLocalArray(Statement *stmt, Object *obj, Object *dtor, SInt32 count, SInt32 size);
-
 TempNodeCB cinit_tempnodefunc;
 InitInfo *cinit_initinfo;
 static PooledString *cinit_stringlist;
@@ -803,7 +799,7 @@ static void CInit_InitTypeArray(CInit_Stuff *s, CInit_Stuff2 *s2, TypePointer *t
     }
 }
 
-static void CInit_InitTypeStruct(CInit_Stuff *s, CInit_Stuff2 *s2, TypeStruct *tstruct, UInt32 qual, Boolean errorflag) {
+static void CInit_InitTypeStruct(CInit_Stuff *s, CInit_Stuff2 *s2, const TypeStruct *tstruct, UInt32 qual, Boolean errorflag) {
     StructMember *member;
     SInt32 start;
     Boolean flag;
@@ -1257,7 +1253,7 @@ static ENode *CInit_RegisterDtorObject(Type *type, Object *dtor, ENode *objexpr)
     expr->data.funccall.args = lalloc(sizeof(ENodeList));
     expr->data.funccall.args->node = objexpr;
     expr->data.funccall.args->next = lalloc(sizeof(ENodeList));
-    expr->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+    expr->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
     expr->data.funccall.args->next->next = lalloc(sizeof(ENodeList));
     expr->data.funccall.args->next->next->node = create_objectrefnode(CInit_CreateStaticData(CInit_GetRegMemType()));
     expr->data.funccall.args->next->next->next = NULL;
@@ -1266,7 +1262,7 @@ static ENode *CInit_RegisterDtorObject(Type *type, Object *dtor, ENode *objexpr)
 }
 
 static Boolean CInit_ConstructGlobalObject(Object *obj, TypeClass *tclass, ENode *valueexpr, SInt32 offset, Boolean flag) {
-    Object *ctor;
+    NameSpaceObjectList *ctor;
     Object *dtor;
     ENodeList *list;
     ENode *expr;
@@ -1336,7 +1332,7 @@ static Boolean CInit_ConstructGlobalObject(Object *obj, TypeClass *tclass, ENode
 static Boolean CInit_ConstructAutoObject(TypeClass *tclass, ENode *expr, SInt32 offset, Boolean flag) {
     ENodeList *r30;
     ENode *r29;
-    Object *ctor;
+    NameSpaceObjectList *ctor;
     Object *dtor;
     Boolean r24;
 
@@ -1920,7 +1916,7 @@ static void CInit_AutoInit(Type *type, ENode *valueexpr, Boolean flag) {
             copy = galloc(sizeof(TypePointer));
             *TYPE_POINTER(copy) = *TYPE_POINTER(type);
             type = copy;
-            copy->size = type->size + 1;
+            type->size++;
         }
         expr = create_objectrefnode(cinit_initinfo->obj1C);
         if (!IS_TYPE_POINTER_ONLY(expr->rtype)) {
@@ -2163,7 +2159,7 @@ Statement *CInit_ConstructClassArray(Statement *stmt, TypeClass *tclass, Object
         stmt = CFunc_AppendStatement(ST_EXPRESSION);
 
     if (dtor)
-        dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+        dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
     else
         dtor_expr = nullnode();
 
@@ -2236,7 +2232,7 @@ static void CInit_InitializeClassArray(Object *obj, TypeClass *tclass, Boolean f
                 expr = nullnode();
             } else {
                 if (dtor)
-                    dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+                    dtor_expr = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
                 else
                     dtor_expr = nullnode();
                 expr = CExpr_FuncCallSix(
@@ -2270,7 +2266,7 @@ static void CInit_InitializeClassArray(Object *obj, TypeClass *tclass, Boolean f
                 CParser_RegisterSingleExprFunction(funcobj, funccallexpr(
                         darr_func,
                         create_objectrefnode(obj),
-                        create_objectrefnode(CABI_GetDestructorObject(dtor, 1)),
+                        create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1)),
                         intconstnode(TYPE(&stsignedlong), tclass->size),
                         intconstnode(TYPE(&stsignedlong), count)
                 ));
@@ -2330,7 +2326,7 @@ static ENode *CInit_GlobalTempNode(Type *type, Boolean flag) {
         funcnode->data.funccall.args = lalloc(sizeof(ENodeList));
         funcnode->data.funccall.args->node = node;
         funcnode->data.funccall.args->next = lalloc(sizeof(ENodeList));
-        funcnode->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, 1));
+        funcnode->data.funccall.args->next->node = create_objectrefnode(CABI_GetDestructorObject(dtor, CABIDestroy1));
         funcnode->data.funccall.args->next->next = lalloc(sizeof(ENodeList));
         funcnode->data.funccall.args->next->next->node = create_objectrefnode(CInit_CreateStaticData(CInit_GetRegMemType()));;
         funcnode->data.funccall.args->next->next->next = NULL;
@@ -2641,7 +2637,7 @@ void CInit_InitializeAutoData(Object *obj, InsertExprCB insert_cb, RegisterObjec
     }
 
     if (IS_TYPE_CLASS(obj->type) && CClass_Destructor(TYPE_CLASS(obj->type)))
-        register_cb(obj->type, obj, 0, NULL);
+        register_cb(obj->type, obj, 0, 0);
 
     CInit_CleanupInitInfo(&initinfo);
 }
diff --git a/compiler_and_linker/unsorted/CMangler.c b/compiler_and_linker/unsorted/CMangler.c
index e3e3c3e..c1b9618 100644
--- a/compiler_and_linker/unsorted/CMangler.c
+++ b/compiler_and_linker/unsorted/CMangler.c
@@ -47,54 +47,54 @@ HashNameNode *CMangler_DeleteDtorName(void) {
     return GetHashNameNodeExport("__dt");
 }
 
-char *CMangler_GetOperator(HashNameNode *opname) {
-    char *name;
+char *CMangler_GetOperator(HashNameNode *name) {
+    char *str;
 
-    if (opname == asop_name_node)
+    if (name == asop_name_node)
         return "operator=";
 
-    name = opname->name;
-    if (!strcmp(name, "__nw")) return "operator new";
-    if (!strcmp(name, "__dl")) return "operator delete";
-    if (!strcmp(name, "__nwa")) return "operator new[]";
-    if (!strcmp(name, "__dla")) return "operator delete[]";
-    if (!strcmp(name, "__pl")) return "operator+";
-    if (!strcmp(name, "__mi")) return "operator-";
-    if (!strcmp(name, "__ml")) return "operator*";
-    if (!strcmp(name, "__dv")) return "operator/";
-    if (!strcmp(name, "__md")) return "operator%";
-    if (!strcmp(name, "__er")) return "operator^";
-    if (!strcmp(name, "__ad")) return "operator&";
-    if (!strcmp(name, "__or")) return "operator|";
-    if (!strcmp(name, "__co")) return "operator~";
-    if (!strcmp(name, "__nt")) return "operator!";
-    if (!strcmp(name, "__lt")) return "operator<";
-    if (!strcmp(name, "__gt")) return "operator>";
-    if (!strcmp(name, "__apl")) return "operator+=";
-    if (!strcmp(name, "__ami")) return "operator-=";
-    if (!strcmp(name, "__amu")) return "operator*=";
-    if (!strcmp(name, "__adv")) return "operator/=";
-    if (!strcmp(name, "__amd")) return "operator%=";
-    if (!strcmp(name, "__aer")) return "operator^=";
-    if (!strcmp(name, "__aad")) return "operator&=";
-    if (!strcmp(name, "__aor")) return "operator|=";
-    if (!strcmp(name, "__ls")) return "operator<<";
-    if (!strcmp(name, "__rs")) return "operator>>";
-    if (!strcmp(name, "__als")) return "operator<<=";
-    if (!strcmp(name, "__ars")) return "operator>>=";
-    if (!strcmp(name, "__eq")) return "operator==";
-    if (!strcmp(name, "__ne")) return "operator!=";
-    if (!strcmp(name, "__le")) return "operator<=";
-    if (!strcmp(name, "__ge")) return "operator>=";
-    if (!strcmp(name, "__aa")) return "operator&&";
-    if (!strcmp(name, "__oo")) return "operator||";
-    if (!strcmp(name, "__pp")) return "operator++";
-    if (!strcmp(name, "__mm")) return "operator--";
-    if (!strcmp(name, "__cm")) return "operator,";
-    if (!strcmp(name, "__rm")) return "operator->*";
-    if (!strcmp(name, "__rf")) return "operator*";
-    if (!strcmp(name, "__cl")) return "operator()";
-    if (!strcmp(name, "__vc")) return "operator[]";
+    str = name->name;
+    if (!strcmp(str, "__nw")) return "operator new";
+    if (!strcmp(str, "__dl")) return "operator delete";
+    if (!strcmp(str, "__nwa")) return "operator new[]";
+    if (!strcmp(str, "__dla")) return "operator delete[]";
+    if (!strcmp(str, "__pl")) return "operator+";
+    if (!strcmp(str, "__mi")) return "operator-";
+    if (!strcmp(str, "__ml")) return "operator*";
+    if (!strcmp(str, "__dv")) return "operator/";
+    if (!strcmp(str, "__md")) return "operator%";
+    if (!strcmp(str, "__er")) return "operator^";
+    if (!strcmp(str, "__ad")) return "operator&";
+    if (!strcmp(str, "__or")) return "operator|";
+    if (!strcmp(str, "__co")) return "operator~";
+    if (!strcmp(str, "__nt")) return "operator!";
+    if (!strcmp(str, "__lt")) return "operator<";
+    if (!strcmp(str, "__gt")) return "operator>";
+    if (!strcmp(str, "__apl")) return "operator+=";
+    if (!strcmp(str, "__ami")) return "operator-=";
+    if (!strcmp(str, "__amu")) return "operator*=";
+    if (!strcmp(str, "__adv")) return "operator/=";
+    if (!strcmp(str, "__amd")) return "operator%=";
+    if (!strcmp(str, "__aer")) return "operator^=";
+    if (!strcmp(str, "__aad")) return "operator&=";
+    if (!strcmp(str, "__aor")) return "operator|=";
+    if (!strcmp(str, "__ls")) return "operator<<";
+    if (!strcmp(str, "__rs")) return "operator>>";
+    if (!strcmp(str, "__als")) return "operator<<=";
+    if (!strcmp(str, "__ars")) return "operator>>=";
+    if (!strcmp(str, "__eq")) return "operator==";
+    if (!strcmp(str, "__ne")) return "operator!=";
+    if (!strcmp(str, "__le")) return "operator<=";
+    if (!strcmp(str, "__ge")) return "operator>=";
+    if (!strcmp(str, "__aa")) return "operator&&";
+    if (!strcmp(str, "__oo")) return "operator||";
+    if (!strcmp(str, "__pp")) return "operator++";
+    if (!strcmp(str, "__mm")) return "operator--";
+    if (!strcmp(str, "__cm")) return "operator,";
+    if (!strcmp(str, "__rm")) return "operator->*";
+    if (!strcmp(str, "__rf")) return "operator*";
+    if (!strcmp(str, "__cl")) return "operator()";
+    if (!strcmp(str, "__vc")) return "operator[]";
     return NULL;
 }
 
@@ -146,12 +146,12 @@ HashNameNode *CMangler_OperatorName(short token) {
     }
 }
 
-HashNameNode *CMangler_VTableName(TypeClass *tclass) {
+HashNameNode *CMangler_VTableName(TypeClass *theclass) {
     HashNameNode *name;
 
     name_mangle_list.size = 0;
     AppendGListName(&name_mangle_list, "__vt__");
-    CMangler_MangleClassName(tclass);
+    CMangler_MangleClassName(theclass);
     AppendGListByte(&name_mangle_list, 0);
     COS_LockHandle(name_mangle_list.data);
     name = GetHashNameNodeExport(*name_mangle_list.data);
@@ -172,20 +172,20 @@ HashNameNode *CMangler_RTTIObjectName(Type *type, UInt32 qual) {
     return name;
 }
 
-HashNameNode *CMangler_ThunkName(Object *obj, int a, int b, int c) {
+HashNameNode *CMangler_ThunkName(Object *vfunc, SInt32 this_delta, SInt32 return_delta, SInt32 ctoroffset) {
     HashNameNode *linkname;
     HashNameNode *name;
     char buf[64];
 
-    linkname = CMangler_GetLinkName(obj);
+    linkname = CMangler_GetLinkName(vfunc);
     name_mangle_list.size = 0;
-    if (b == 0) {
-        if (c < 0)
-            sprintf(buf, "_@%ld@", -a);
+    if (return_delta == 0) {
+        if (ctoroffset < 0)
+            sprintf(buf, "_@%ld@", -this_delta);
         else
-            sprintf(buf, "_@%ld@%ld@", -a, c);
+            sprintf(buf, "_@%ld@%ld@", -this_delta, ctoroffset);
     } else {
-        sprintf(buf, "_@%ld@%ld@%ld@", -a, c, b);
+        sprintf(buf, "_@%ld@%ld@%ld@", -this_delta, ctoroffset, return_delta);
     }
     AppendGListName(&name_mangle_list, buf);
     AppendGListID(&name_mangle_list, linkname->name + 1);
@@ -640,15 +640,14 @@ static HashNameNode *CMangler_FunctionLinkName(Object *obj) {
     return name;
 }
 
-HashNameNode *CMangler_GetCovariantFunctionName(Object *obj, Type *type) {
-    HashNameNode *linkname;
+HashNameNode *CMangler_GetCovariantFunctionName(Object *dobj, TypeClass *theclass) {
     HashNameNode *name;
 
-    linkname = CMangler_GetLinkName(obj);
+    name = CMangler_GetLinkName(dobj);
     name_mangle_list.size = 0;
-    AppendGListName(&name_mangle_list, linkname->name);
+    AppendGListName(&name_mangle_list, name->name);
     AppendGListName(&name_mangle_list, "@@");
-    CMangler_MangleTypeAppend(type, 0);
+    CMangler_MangleTypeAppend(TYPE(theclass), 0);
     AppendGListByte(&name_mangle_list, 0);
 
     COS_LockHandle(name_mangle_list.data);
diff --git a/compiler_and_linker/unsorted/CParser.c b/compiler_and_linker/unsorted/CParser.c
index 8228159..85ccf26 100644
--- a/compiler_and_linker/unsorted/CParser.c
+++ b/compiler_and_linker/unsorted/CParser.c
@@ -8,46 +8,26 @@
 #include "compiler/CInit.h"
 #include "compiler/CInline.h"
 #include "compiler/CInt64.h"
+#include "compiler/CIRTransform.h"
 #include "compiler/CMachine.h"
 #include "compiler/CMangler.h"
+#include "compiler/CObjC.h"
 #include "compiler/CPrep.h"
 #include "compiler/CPrepTokenizer.h"
 #include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CTemplateTools.h"
 #include "compiler/CodeGen.h"
 #include "compiler/CompilerTools.h"
+#include "compiler/IrOptimizer.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/ObjGenMachO.h"
 #include "compiler/objects.h"
 #include "compiler/scopes.h"
 #include "compiler/templates.h"
 #include "cos.h"
 
-// TODO MOVE ME
-extern SInt32 symdecloffset;
-extern void CSOM_Setup(Boolean is_precompiler);
-extern void CSOM_Cleanup(void);
-extern void CIRTrans_Setup(void);
-extern void CObjC_Setup(void);
-extern void CObjC_GenerateModule(void);
-extern Type *CObjC_ParseTypeProtocol(Type *type);
-extern void CObjC_ParseProtocol(void);
-extern void CObjC_ParseClassDeclaration(void);
-extern void CObjC_ParseInterface(void);
-extern void CObjC_ParseImplementation(void);
-extern void CTempl_Setup(void);
-extern void CTempl_Parse(TypeClass *tclass, short access);
-extern Boolean CTempl_Instantiate(void);
-extern Boolean CInline_GenerateDeferredFuncs(void);
-extern void CTempl_Cleanup();
-extern void CIRTrans_Cleanup();
-extern void CObjC_Cleanup();
-extern void PointerAnalysis_ParseFunctionModifiesSpecifier(DeclInfo *declinfo);
-extern void PointerAnalysis_ParseExitPointsToSpecifier(DeclInfo *declinfo);
-extern void PointerAnalysis_ParseEntryPointsToSpecifier(DeclInfo *declinfo);
-extern Boolean CTemplTool_TemplDepTypeCompare(TypeTemplDep *a, TypeTemplDep *b);
-extern Boolean CTemplTool_IsSameTemplateType(Type *a, Type *b);
-extern TemplStack *ctempl_curinstance;
-extern Type *CObjC_ParseID(void);
-extern void CodeGen_UpdateOptimizerOptions(void);
-
 FileOffsetInfo cparser_fileoffset;
 TStreamElement symdecltoken;
 ParserTryBlock *trychain;
@@ -276,16 +256,14 @@ static void CParser_SetupRuntimeObjects(void) {
     func = CParser_NewRTFunc(
             TYPE(&stvoid), CMangler_OperatorName(TK_DELETE), 1,
             1, &void_ptr);
-#line 379
-    CError_ASSERT(IS_TYPE_FUNC(func->type));
+    CError_ASSERT(379, IS_TYPE_FUNC(func->type));
     TYPE_FUNC(func->type)->exspecs = exspecs;
     CScope_AddGlobalObject(func);
 
     func = CParser_NewRTFunc(
             TYPE(&stvoid), CMangler_OperatorName(TK_DELETE_ARRAY), 1,
             1, &void_ptr);
-#line 387
-    CError_ASSERT(IS_TYPE_FUNC(func->type));
+    CError_ASSERT(387, IS_TYPE_FUNC(func->type));
     TYPE_FUNC(func->type)->exspecs = exspecs;
     CScope_AddGlobalObject(func);
 
@@ -374,8 +352,7 @@ static void CParser_SetupRuntimeObjects(void) {
             1, &void_ptr);
 
     CodeGen_SetupRuntimeObjects();
-#line 534
-    CError_ASSERT(CParser_ReInitRuntimeObjects(0));
+    CError_ASSERT(534, CParser_ReInitRuntimeObjects(0));
 }
 
 void CParser_Setup(void) {
@@ -825,8 +802,7 @@ FuncArg *CParser_NewFuncArg(void) {
 Type *atomtype(void) {
     switch (tksize) {
         default:
-#line 1145
-            CError_FATAL();
+            CError_FATAL(1145);
         case ATOM_VOID: return &stvoid;
         case ATOM_CHAR: return TYPE(&stchar);
         case ATOM_WCHAR: return TYPE(&stwchar);
@@ -853,8 +829,8 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
     CScopeParseResult pr;
     Boolean first_time;
     Boolean retry_flag;
-    Type *sizet;
     Object *obj;
+    Type *sizet;
 
     list = NULL;
     *outflag = 0;
@@ -867,13 +843,11 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
                 mylist.object = pr.obj_10;
                 list = &mylist;
             } else {
-#line 1202
-                CError_ASSERT(pr.nsol_14);
+                CError_ASSERT(1202, pr.nsol_14);
                 list = pr.nsol_14;
             }
         } else if (TYPE_CLASS(type)->flags & CLASS_FLAGS_1) {
-#line 1210
-            CError_ASSERT(!args && !flag1);
+            CError_ASSERT(1210, !args && !flag1);
             return delh_func;
         }
     }
@@ -894,8 +868,7 @@ Object *CParser_FindDeallocationObject(Type *type, FuncArg *args, Boolean flag1,
                             return obj;
             }
 
-#line 1231
-            CError_ASSERT(first_time);
+            CError_ASSERT(1231, first_time);
 
             sizet = CABI_GetSizeTType();
             for (scan = list; scan; scan = scan->next) {
@@ -1014,19 +987,14 @@ short is_memberpointerequal(Type *a, Type *b) {
     if ((TYPE_FUNC(a)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)) != (TYPE_FUNC(b)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)))
         return 0;
 
-#line 1345
-    CError_ASSERT((arg_a = TYPE_FUNC(a)->args));
-    CError_ASSERT((arg_b = TYPE_FUNC(b)->args));
+    CError_ASSERT(1345, arg_a = TYPE_FUNC(a)->args);
+    CError_ASSERT(1346, arg_b = TYPE_FUNC(b)->args);
 
-    if (TYPE_FUNC(a)->flags & FUNC_FLAGS_80) {
-#line 1351
-        CError_ASSERT((arg_a = arg_a->next));
-    }
+    if (TYPE_FUNC(a)->flags & FUNC_FLAGS_80)
+        CError_ASSERT(1351, arg_a = arg_a->next);
 
-    if (TYPE_FUNC(b)->flags & FUNC_FLAGS_80) {
-#line 1355
-        CError_ASSERT((arg_b = arg_b->next));
-    }
+    if (TYPE_FUNC(b)->flags & FUNC_FLAGS_80)
+        CError_ASSERT(1355, arg_b = arg_b->next);
 
     if (arg_a->qual != arg_b->qual)
         return 0;
@@ -1082,8 +1050,7 @@ restart:
         case TYPETEMPLATE:
             return CTemplTool_TemplDepTypeCompare(TYPE_TEMPLATE(a), TYPE_TEMPLATE(b));
         default:
-#line 1441
-            CError_FATAL();
+            CError_FATAL(1441);
             return 0;
     }
 }
@@ -1135,8 +1102,7 @@ short iscpp_typeequal(Type *a, Type *b) {
         case TYPETEMPLATE:
             return CTemplTool_TemplDepTypeCompare(TYPE_TEMPLATE(a), TYPE_TEMPLATE(b));
         default:
-#line 1500
-            CError_FATAL();
+            CError_FATAL(1500);
             return 0;
     }
 }
@@ -1311,10 +1277,9 @@ restart:
                 return 0;
             if ((TYPE_FUNC(a)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)) != (TYPE_FUNC(b)->flags & (FUNC_FLAGS_F0000000 | FUNC_FLAGS_PASCAL)))
                 return 0;
-            return is_arglistequal(TYPE_FUNC(a)->args, TYPE_FUNC(b)->args);
+            return is_arglistsame(TYPE_FUNC(a)->args, TYPE_FUNC(b)->args);
         default:
-#line 1709
-            CError_FATAL();
+            CError_FATAL(1709);
             return 0;
     }
 }
@@ -1336,8 +1301,7 @@ Type *CParser_GetWCharType(void) {
 short CParser_GetOperator(ENodeType t) {
     switch (t) {
         default:
-#line 1748
-            CError_FATAL();
+            CError_FATAL(1748);
         case EMONMIN: return '-';
         case EBINNOT: return '~';
         case ELOGNOT: return '!';
@@ -1757,7 +1721,7 @@ Boolean CParserIsVolatileExpr(ENode *expr) {
     return CParser_IsVolatile(expr->rtype, expr->flags & ENODE_FLAG_QUALS);
 }
 
-Boolean CParser_HasInternalLinkage(Object *obj) {
+Boolean CParser_HasInternalLinkage(const Object *obj) {
     NameSpace *nspace;
 
     for (nspace = obj->nspace; nspace; nspace = nspace->parent) {
@@ -1769,24 +1733,26 @@ Boolean CParser_HasInternalLinkage(Object *obj) {
         return 1;
     if (obj->qual & (Q_20000 | Q_OVERLOAD))
         return 0;
-    if (obj->sclass == OBJECT_SCLASS_102)
+    if (obj->sclass == TK_STATIC)
         return 1;
 
+    // this feels *wrong* but it's the only way to match this function that I can see
     if (obj->qual & Q_INLINE)
-        obj->qual |= Q_20000;
+        ((Object *) obj)->qual |= Q_20000;
     return 0;
 }
 
-Boolean CParser_HasInternalLinkage2(Object *obj) {
+Boolean CParser_HasInternalLinkage2(const Object *obj) {
     if (obj->datatype == DLOCAL)
         return 1;
     if (obj->qual & (Q_20000 | Q_OVERLOAD))
         return 0;
-    if (obj->sclass == OBJECT_SCLASS_102)
+    if (obj->sclass == TK_STATIC)
         return 1;
 
+    // this feels *wrong* but it's the only way to match this function that I can see
     if (obj->qual & Q_INLINE)
-        obj->qual |= Q_20000;
+        ((Object *) obj)->qual |= Q_20000;
     return 0;
 }
 
@@ -2036,8 +2002,7 @@ void CParser_ParseAttribute(Type *type, DeclInfo *declinfo) {
                         declinfo->qual |= Q_ALIGNED_8192;
                         break;
                     default:
-#line 2779
-                        CError_FATAL();
+                        CError_FATAL(2779);
                         break;
                 }
             } else {
@@ -2638,10 +2603,10 @@ void CParser_GetDeclSpecs(DeclInfo *di, Boolean flag) {
     SInt32 state;
     CScopeParseResult pr;
 
-    di->fileoffsetinfo.file = CPrep_BrowserCurrentFile();
+    di->file = CPrep_BrowserCurrentFile();
     CPrep_BrowserFilePosition(
-            (CPrepFileInfo **) &di->fileoffsetinfo.tokenline,
-            &di->fileoffsetinfo.tokenoffset);
+            (CPrepFileInfo **) &di->file2,
+            &di->x60);
 
     r24 = 1;
     r23 = copts.cplusplus;
@@ -2940,8 +2905,7 @@ restart:
                                             pr.x8 = TYPE(&stsignedint);
                                             break;
                                         default:
-#line 4109
-                                            CError_FATAL();
+                                            CError_FATAL(4109);
                                     }
                                     break;
                                 case TEMPLDEP_QUALNAME:
@@ -2954,8 +2918,7 @@ restart:
                                 case TEMPLDEP_BITFIELD:
                                     break;
                                 default:
-#line 4136
-                                    CError_FATAL();
+                                    CError_FATAL(4136);
                             }
                         }
 
@@ -2980,7 +2943,7 @@ restart:
                         typetoken = -1;
                         tk = lex();
                         if (tk == '<' && copts.objective_c && IS_TYPE_CLASS(di->thetype) && TYPE_CLASS(di->thetype)->objcinfo)
-                            di->thetype = CObjC_ParseTypeProtocol(di->thetype);
+                            di->thetype = CObjC_ParseTypeProtocol(TYPE_CLASS(di->thetype));
                         goto bailOut;
                     } else if (pr.nsol_14) {
                         if (pr.x1D) {
@@ -3010,8 +2973,7 @@ restart:
                                 CError_Error(121);
                                 break;
                             default:
-#line 4217
-                                CError_FATAL();
+                                CError_FATAL(4217);
                         }
                     } else if (pr.name_4) {
                         if (copts.cplusplus)
@@ -3022,8 +2984,7 @@ restart:
                         tk = lex();
                         r23 = 0;
                     } else {
-#line 4234
-                        CError_FATAL();
+                        CError_FATAL(4234);
                     }
                 }
             }
@@ -3216,8 +3177,7 @@ void CParser_CallBackAction(Object *obj) {
         }
     }
 
-#line 4551
-    CError_FATAL();
+    CError_FATAL(4551);
 }
 
 static Object *CParser_FindOverloadFunc(NameSpaceObjectList *list, TypeFunc *tfunc) {
diff --git a/compiler_and_linker/unsorted/CPrec.c b/compiler_and_linker/unsorted/CPrec.c
index f835c6c..6e0692b 100644
--- a/compiler_and_linker/unsorted/CPrec.c
+++ b/compiler_and_linker/unsorted/CPrec.c
@@ -1,6 +1,17 @@
-#include "compiler.h"
-#include "compiler/CompilerTools.h"
+#include "compiler/CPrec.h"
 #include "compiler/CError.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInit.h"
+#include "compiler/CInline.h"
+#include "compiler/CMachine.h"
+#include "compiler/CObjC.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CScope.h"
+#include "compiler/CSOM.h"
+#include "compiler/CTemplateNew.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
 #include "compiler/enode.h"
 #include "compiler/objc.h"
 #include "compiler/objects.h"
@@ -9,84 +20,90 @@
 #include "compiler/templates.h"
 #include "compiler/types.h"
 #include "cos.h"
-
-// HACKS
-extern Type stvoid;
-extern Type stbool;
-extern Type stchar;
-extern Type stsignedchar;
-extern Type stunsignedchar;
-extern Type stwchar;
-extern Type stsignedshort;
-extern Type stunsignedshort;
-extern Type stsignedint;
-extern Type stunsignedint;
-extern Type stsignedlong;
-extern Type stunsignedlong;
-extern Type stsignedlonglong;
-extern Type stunsignedlonglong;
-extern Type stfloat;
-extern Type stshortdouble;
-extern Type stdouble;
-extern Type stlongdouble;
-extern Type elipsis;
-extern Type oldstyle;
-extern Type stillegal;
-extern Type sttemplexpr;
-extern Type stvoid;
-extern Type void_ptr;
-extern Type rt_func;
-extern Type catchinfostruct;
-extern void * newh_func;
-extern void * delh_func;
-extern void * copy_func;
-extern void * clear_func;
-extern void * Rgtid_func;
-extern void * Rdync_func;
-extern void * rt_ptmf_cast;
-extern void * rt_ptmf_cmpr;
-extern void * rt_ptmf_test;
-extern void * rt_ptmf_call;
-extern void * rt_ptmf_scall;
-extern void * rt_ptmf_null;
-extern void * rt_som_glue1;
-extern void * rt_som_glue2;
-extern void * rt_som_glue3;
-extern void * rt_som_check;
-extern void * rt_som_new;
-extern void * rt_som_newcheck;
-extern void * rt_ptmf_call4;
-extern void * rt_ptmf_scall4;
-extern void * carr_func;
-extern void * cnar_func;
-extern void * darr_func;
-extern void * dnar_func;
-extern void * dnar3_func;
-extern void * Xgreg_func;
-extern void * Xthrw_func;
-extern void * Xicth_func;
-extern void * Xecth_func;
-extern void * Xunex_func;
-extern Type stvectorunsignedchar;
-extern Type stvectorsignedchar;
-extern Type stvectorboolchar;
-extern Type stvectorunsignedshort;
-extern Type stvectorsignedshort;
-extern Type stvectorboolshort;
-extern Type stvectorunsignedlong;
-extern Type stvectorsignedlong;
-extern Type stvectorboollong;
-extern Type stvectorfloat;
-extern Type stvectorpixel;
-// HACKS
-
-// PUBLIC FUNCTIONS
-extern void SetupPrecompiler();
-extern void CleanupPrecompiler();
-extern void PreComp_StaticData(Object *obj, const void *data, void *unk1, void *unk2);
-extern void PrecompilerWrite();
-extern void PrecompilerRead(short refnum, void *buffer);
-// END PUBLIC FUNCTIONS
+#include "compiler/CCompiler.h"
+#include "compiler/InlineAsm.h"
+
+#define RESOLVE_BUFFER(offset) ((void *) (((char *) cprec_buffer) + ((uintptr_t) (offset))))
+#define RESOLVE_RAW_BUFFER(offset) ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset))))
+#define RESOLVE_SAFE(offset) (!(offset) ? NULL : ((void *) (((char *) cprec_rawbuffer) + ((uintptr_t) (offset)))))
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct StaticData {
+    struct StaticData *next;
+    Object *object;
+    void *buffer;
+    OLinkList *links;
+    SInt32 size;
+} StaticData;
+
+typedef struct Header {
+    UInt32 magic;
+    UInt16 version;
+    UInt16 x6;
+    char target;
+    Boolean check_header_flags;
+    Boolean cplusplus;
+    UInt32 xC;
+    UInt32 x10;
+    UInt32 x14;
+    UInt32 x18;
+    UInt32 x1C;
+    UInt32 x20;
+    UInt32 x24;
+    UInt32 x28;
+    UInt32 x2C;
+    UInt32 x30;
+    UInt32 compressedPatchCount;
+    UInt32 compressedPatchSize;
+    UInt32 compressedPatchOffset;
+    UInt32 builtinPatchSize;
+    UInt32 builtinPatchOffset;
+    UInt32 tokenStreamPatchSize;
+    UInt32 tokenStreamPatchOffset;
+    UInt32 root_names;
+    NameSpaceList *usings;
+    TemplClass *ctempl_templates;
+    CSOMStub *csom_stubs;
+    StaticData *cprec_staticdata;
+    UInt32 uniqueID;
+    CallbackAction *callbackactions;
+    Type *cobjc_type_class;
+    Type *cobjc_type_id;
+    Type *cobjc_type_sel;
+    ObjCSelector **cobjc_selhashtable;
+    BClassList *cobjc_classdefs;
+    ObjCProtocol *cobjc_protocols;
+    UInt32 cobjc_selrefcount;
+    UInt32 cobjc_classrefcount;
+    UInt32 cobjc_stringcount;
+    InitExpr *init_expressions;
+    CI_Action *cinline_tactionlist;
+    TemplateFunction *ctempl_templatefuncs;
+    UInt32 x9C;
+    UInt32 xA0;
+    UInt32 xA4;
+    UInt32 xA8;
+    UInt32 xAC;
+    UInt32 xB0;
+    UInt32 xB4;
+    UInt32 xB8;
+    UInt32 xBC;
+    UInt32 xC0;
+    UInt32 xC4;
+    UInt32 xC8;
+    UInt32 xCC;
+    UInt32 xD0;
+    UInt32 xD4;
+    UInt32 xD8;
+    UInt32 xDC;
+    UInt32 xE0;
+    UInt32 xE4;
+    HashNameNode *nametable[0x800];
+    Macro *macrotable[0x800];
+    NameSpaceName *root_nametable[0x400];
+} Header;
 
 typedef struct Patch {
     struct Patch *next;
@@ -121,31 +138,41 @@ typedef struct TokenPatch {
     SInt32 count;
 } TokenPatch;
 static TokenPatch *cprec_tokenpatches;
+static StaticData *cprec_staticdata;
+
+typedef struct PointerHash {
+    struct PointerHash *next;
+    TypePointer *tptr;
+    TypePointer *prec_tptr;
+} PointerHash;
+static PointerHash **cprec_pointerhash;
 
-static void *cprec_staticdata;
-static void *cprec_pointerhash;
 static BuiltIn *cprec_builtin;
 static Patch *cprec_patch_list;
 static AddrPatch **cprec_addrhash;
-static void *cprec_header;
+static Header *cprec_header;
 static GList cprec_glist;
 static short cprec_refnum;
 char *precomp_target_str;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
 
 // Assorted forward declarations
 static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace);
 static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj);
 static Object *CPrec_GetObjectPatch(Object *obj);
 static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj);
-static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *obj);
+static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar);
 static Type *CPrec_GetTypePatch(Type *type);
-static ENode *CPrec_GetExpressionPatch(ENode *enode);
+static ENode *CPrec_GetExpressionPatch(ENode *expr);
 static ObjCMethod *CPrec_GetObjCMethodPatch(ObjCMethod *meth);
 static ObjCProtocolList *CPrec_GetObjCProtocolListPatch(ObjCProtocolList *lst);
 static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg);
-static OSErr CPrec_FlushBufferCheck();
+static NameSpaceObjectList *CPrec_GetNameSpaceObjectListPatch(NameSpaceObjectList *nsol);
+static OSErr CPrec_FlushBufferCheck(void);
 
-void SetupPrecompiler() {
+void SetupPrecompiler(void) {
     cprec_refnum = 0;
     cprec_glist.data = NULL;
     cprec_header = NULL;
@@ -153,7 +180,7 @@ void SetupPrecompiler() {
     cprec_ioerror = noErr;
 }
 
-void CleanupPrecompiler() {
+void CleanupPrecompiler(void) {
     if (cprec_refnum) {
         COS_FileClose(cprec_refnum);
         cprec_refnum = 0;
@@ -163,20 +190,49 @@ void CleanupPrecompiler() {
         FreeGList(&cprec_glist);
 }
 
-static void CPrec_OLinkListCopy() {}
+static OLinkList *CPrec_OLinkListCopy(OLinkList *list) {
+    OLinkList *copy;
+
+    if (!list)
+        return NULL;
+
+    copy = galloc(sizeof(OLinkList));
+    *copy = *list;
+    copy->next = CPrec_OLinkListCopy(copy->next);
+    return copy;
+}
+
+void PreComp_StaticData(Object *obj, const void *data, OLinkList *links, SInt32 size) {
+    StaticData *entry;
+
+    if (obj->sclass != TK_STATIC && !(obj->qual & (Q_20000 | Q_OVERLOAD)))
+        CError_Error(CErrorStr180);
 
-void PreComp_StaticData(Object *obj, const void *data, void *unk1, void *unk2) {
+    entry = galloc(sizeof(StaticData));
+    entry->object = obj;
+    entry->size = size;
 
+    entry->next = cprec_staticdata;
+    cprec_staticdata = entry;
+
+    if (data) {
+        entry->buffer = galloc(obj->type->size);
+        memcpy(entry->buffer, data, obj->type->size);
+    } else {
+        entry->buffer = NULL;
+    }
+
+    entry->links = CPrec_OLinkListCopy(links);
 }
 
-static void CPrec_InitAddressHashTable() {
+static void CPrec_InitAddressHashTable(void) {
     cprec_addrhash = lalloc(0x4000 * sizeof(AddrPatch *));
     memclrw(cprec_addrhash, 0x4000 * sizeof(AddrPatch *));
 }
 
-static void CPrec_InitPointerHashTable() {
-    cprec_pointerhash = lalloc(0x1000);
-    memclrw(cprec_pointerhash, 0x1000);
+static void CPrec_InitPointerHashTable(void) {
+    cprec_pointerhash = lalloc(0x400 * sizeof(PointerHash *));
+    memclrw(cprec_pointerhash, 0x400 * sizeof(PointerHash *));
 }
 
 static int CPrec_AddressHashVal(void *addr) {
@@ -214,7 +270,7 @@ static AddrPatch *CPrec_NewAddrPatch(void *addr, void *value) {
     return patch;
 }
 
-static void CPrec_SetupBuiltInArray() {
+static void CPrec_SetupBuiltInArray(void) {
     int count1, count2;
     Boolean flag;
     void **array;
@@ -303,7 +359,7 @@ static void CPrec_SetupBuiltInArray() {
     }
 }
 
-static void CPrec_SetupBuiltIn() {
+static void CPrec_SetupBuiltIn(void) {
     int x;
 
     CPrec_SetupBuiltInArray();
@@ -321,13 +377,11 @@ static void CPrec_NewPointerPatch(void *src, void *ptr) {
     if (cprec_dowrite) {
         Patch *patch = lalloc(sizeof(Patch));
         patch->offset = (SInt32) src;
-#line 507
-        CError_ASSERT((patch->offset & 0x80000001) == 0);
+        CError_ASSERT(507, (patch->offset & 0x80000001) == 0);
 
         if ((SInt32) ptr < 0) {
             ptr = (void *) ~((SInt32) ptr);
-#line 513
-            CError_ASSERT((SInt32) ptr < cprec_builtins);
+            CError_ASSERT(513, (SInt32) ptr < cprec_builtins);
 
             patch->next = cprec_builtin[(SInt32) ptr].patches;
             cprec_builtin[(SInt32) ptr].patches = patch;
@@ -338,8 +392,7 @@ static void CPrec_NewPointerPatch(void *src, void *ptr) {
         }
 
         src = (void *)((char *) src - cprec_zero_offset);
-#line 525
-        CError_ASSERT((SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
+        CError_ASSERT(525, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
         *((void **) (*cprec_glist.data + (SInt32) src)) = ptr;
     }
 }
@@ -349,21 +402,17 @@ static void CPrec_ExistingPointerPatch(void *src, void *ptr) {
         AddrPatch *addrPatch;
         Patch *patch;
 
-        addrPatch = CPrec_FindAddrPatch(ptr);
-#line 543
-        CError_ASSERT(addrPatch);
+        CError_ASSERT(543, addrPatch = CPrec_FindAddrPatch(ptr));
 
         patch = lalloc(sizeof(Patch));
         patch->offset = (SInt32) src;
         patch->next = cprec_patch_list;
         cprec_patch_list = patch;
 
-#line 548
-        CError_ASSERT((patch->offset & 0x80000001) == 0);
+        CError_ASSERT(548, (patch->offset & 0x80000001) == 0);
 
         src = (void *)((char *) src - cprec_zero_offset);
-#line 552
-        CError_ASSERT((SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
+        CError_ASSERT(552, (SInt32) src >= 0 && (SInt32) src <= cprec_glist.size);
         *((void **) (*cprec_glist.data + (SInt32) src)) = addrPatch->value;
     }
 }
@@ -373,7 +422,7 @@ static void CPrec_NamePatch(void *src, HashNameNode *name) {
     CPrec_ExistingPointerPatch(src, name);
 }
 
-static void *CPrec_AppendAlign() {
+static void *CPrec_AppendAlign(void) {
     if (cprec_dowrite) {
         while (cprec_offset & 3) {
             AppendGListByte(&cprec_glist, 0);
@@ -421,17 +470,14 @@ static UInt32 CPrec_AppendPointerPatch(void *v) {
     AddrPatch *addrPatch;
 
     if (v) {
-        addrPatch = CPrec_FindAddrPatch(v);
-#line 644
-        CError_ASSERT(addrPatch);
+        CError_ASSERT(644, addrPatch = CPrec_FindAddrPatch(v));
 
         if (cprec_dowrite) {
             Patch *patch = lalloc(sizeof(Patch));
             patch->offset = cprec_offset;
             patch->next = cprec_patch_list;
             cprec_patch_list = patch;
-#line 651
-            CError_ASSERT((patch->offset & 0x80000001) == 0);
+            CError_ASSERT(651, (patch->offset & 0x80000001) == 0);
         }
 
         return CPrec_AppendPointer(addrPatch->value);
@@ -466,9 +512,141 @@ static void CPrec_RawMemPatch(void *source, const void *data, int len) {
     CPrec_NewPointerPatch(source, ptr);
 }
 
-static void CPrec_DumpNameTable() {}
-static void CPrec_DumpMacroTable() {}
-static void CPrec_GetClassAccessPatch() {}
+static void CPrec_DumpNameTable(void) {
+    HashNameNode *name;
+    int i;
+    HashNameNode *p;
+    HashNameNode *next;
+
+    if (cprec_dowrite) {
+        i = 0;
+        do {
+            name = name_hash_nodes[i];
+            while (name && name->id == 0)
+                name = name->next;
+
+            if (name) {
+                p = CPrec_AppendAlign();
+                cprec_header->nametable[i] = p;
+
+                while (1) {
+                    CPrec_NewAddrPatch(name, p);
+                    CPrec_AppendPointer(NULL);
+                    CPrec_AppendWord32(0);
+                    CPrec_AppendWord16(name->hashval);
+                    CPrec_AppendString(name->name);
+
+                    name = name->next;
+                    while (name && name->id == 0)
+                        name = name->next;
+
+                    if (!name)
+                        break;
+
+                    next = CPrec_AppendAlign();
+                    CPrec_NewPointerPatch(&p->next, next);
+                    p = next;
+                }
+            }
+        } while (++i < 0x800);
+    } else {
+        i = 0;
+        do {
+            if ((name = name_hash_nodes[i])) {
+                p = CPrec_AppendAlign();
+                while (1) {
+                    CPrec_NewAddrPatch(name, p);
+                    CPrec_AppendPointer(NULL);
+                    CPrec_AppendWord32(0);
+                    CPrec_AppendWord16(name->hashval);
+                    CPrec_AppendString(name->name);
+
+                    name = name->next;
+                    if (!name)
+                        break;
+
+                    next = CPrec_AppendAlign();
+                    CPrec_NewPointerPatch(&p->next, next);
+                    p = next;
+                }
+            }
+        } while (++i < 0x800);
+    }
+}
+
+static void CPrec_DumpMacroTable(void) {
+    Macro *macro;
+    int i;
+    int j;
+    Macro *p;
+    Macro *next;
+
+    i = 0;
+    do {
+        for (macro = macrohashtable[i]; macro; macro = macro->next) {
+            if (macro->c) {
+                CPrec_NewAddrPatch(macro->c, (void *) cprec_offset);
+                CPrec_AppendString(macro->c);
+            }
+        }
+    } while (++i < 0x800);
+
+    i = 0;
+    do {
+        macro = macrohashtable[i];
+
+        if (macro) {
+            p = CPrec_AppendAlign();
+            if (cprec_dowrite)
+                cprec_header->macrotable[i] = p;
+
+            while (1) {
+                CPrec_AppendPointer(NULL);
+                CPrec_AppendNamePatch(macro->name);
+                CPrec_AppendPointerPatch(macro->c);
+                CPrec_AppendWord16(macro->xC);
+                CPrec_AppendByte(macro->is_special);
+                CPrec_AppendByte(macro->xF);
+
+                for (j = 1; j < (macro->xC & 0x7FFF); j++)
+                    CPrec_AppendNamePatch(macro->names[j - 1]);
+
+                macro = macro->next;
+                if (!macro)
+                    break;
+
+                next = CPrec_AppendAlign();
+                CPrec_NewPointerPatch(&p->next, next);
+                p = next;
+            }
+        }
+    } while (++i < 0x800);
+}
+
+static BClassList *CPrec_GetClassAccessPatch(BClassList *path) {
+    AddrPatch *addrPatch;
+    BClassList *first, *current, *next;
+
+    if ((addrPatch = CPrec_FindAddrPatch(path)))
+        return addrPatch->value;
+
+    first = current = CPrec_AppendAlign();
+    CPrec_NewAddrPatch(path, first);
+
+    while (1) {
+        CPrec_AppendData(path, sizeof(BClassList));
+        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(path->type));
+        if (!path->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        path = path->next;
+    }
+
+    return first;
+}
 
 static int CPrec_PointerHash(TypePointer *type) {
     Type *target;
@@ -517,8 +695,54 @@ restart:
     return (work + (work >> 24) + (work >> 16) + (work >> 8)) & 0x3FF;
 }
 
-static TypePointer *CPrec_GetTypePointerPatch(TypePointer *type) {
-    // requires copts
+static TypePointer *CPrec_GetTypePointerPatch(TypePointer *tptr) {
+    TypePointer *p;
+    int hash;
+    PointerHash *phash;
+    TypePointer *scan1;
+    TypePointer *scan2;
+
+    if (tptr->qual & Q_100000) {
+        p = CPrec_AppendAlign();
+        CPrec_NewAddrPatch(tptr, p);
+        CPrec_AppendData(tptr, sizeof(TypeObjCID));
+        if (TYPE_OBJC_ID(tptr)->protocols)
+            CPrec_NewPointerPatch(&TYPE_OBJC_ID(p)->protocols, CPrec_GetObjCProtocolListPatch(TYPE_OBJC_ID(tptr)->protocols));
+    } else {
+        if (!copts.faster_pch_gen && cprec_dowrite && tptr->size > 0) {
+            hash = CPrec_PointerHash(tptr);
+            for (phash = cprec_pointerhash[hash]; phash; phash = phash->next) {
+                scan1 = tptr;
+                scan2 = phash->tptr;
+            check_again:
+                if (scan1->type == scan2->type && scan1->size == scan2->size && scan1->qual == scan2->qual) {
+                    scan1 = TYPE_POINTER(TPTR_TARGET(scan1));
+                    scan2 = TYPE_POINTER(TPTR_TARGET(scan2));
+                    if (scan1->type == TYPEPOINTER && scan1->type == TYPEARRAY)
+                        goto check_again;
+                    if (scan1 == scan2)
+                        return phash->prec_tptr;
+                }
+            }
+
+            p = CPrec_AppendAlign();
+            CPrec_NewAddrPatch(tptr, p);
+
+            phash = lalloc(sizeof(PointerHash));
+            phash->tptr = tptr;
+            phash->prec_tptr = p;
+            phash->next = cprec_pointerhash[hash];
+            cprec_pointerhash[hash] = phash;
+        } else {
+            p = CPrec_AppendAlign();
+            CPrec_NewAddrPatch(tptr, p);
+        }
+
+        CPrec_AppendData(tptr, sizeof(TypePointer));
+    }
+
+    CPrec_NewPointerPatch(&p->target, CPrec_GetTypePatch(tptr->target));
+    return p;
 }
 
 static TypeEnum *CPrec_GetTypeEnumPatch(TypeEnum *type) {
@@ -541,15 +765,48 @@ static TypeEnum *CPrec_GetTypeEnumPatch(TypeEnum *type) {
 
 static TypeBitfield *CPrec_GetTypeBitfieldPatch(TypeBitfield *type) {
     TypeBitfield *p = CPrec_AppendAlign();
+
     CPrec_NewAddrPatch(type, p);
     CPrec_AppendData(type, sizeof(TypeBitfield));
-
-    CPrec_NewPointerPatch(&p->bitfieldtype, type->bitfieldtype);
+    CPrec_NewPointerPatch(&p->bitfieldtype, CPrec_GetTypePatch(type->bitfieldtype));
 
     return p;
 }
 
-static TypeStruct *CPrec_GetTypeStructPatch(TypeStruct *type) {}
+static TypeStruct *CPrec_GetTypeStructPatch(TypeStruct *tstruct) {
+    StructMember *member;
+    TypeStruct *p;
+    StructMember *current, *next;
+
+    p = CPrec_AppendAlign();
+    CPrec_NewAddrPatch(tstruct, p);
+    CPrec_AppendData(tstruct, sizeof(TypeStruct));
+
+    if (tstruct->name)
+        CPrec_NamePatch(&p->name, tstruct->name);
+
+    if ((member = tstruct->members)) {
+        current = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&p->members, current);
+
+        while (1) {
+            CPrec_AppendData(member, sizeof(StructMember));
+            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(member->type));
+            CPrec_NamePatch(&current->name, member->name);
+
+            if (!member->next)
+                break;
+
+            next = CPrec_AppendAlign();
+            CPrec_NewPointerPatch(&current->next, next);
+            current = next;
+
+            member = member->next;
+        }
+    }
+
+    return p;
+}
 
 static ExceptSpecList *CPrec_GetExceptSpecPatch(ExceptSpecList *exspec) {
     ExceptSpecList *first, *current, *next;
@@ -572,40 +829,40 @@ static ExceptSpecList *CPrec_GetExceptSpecPatch(ExceptSpecList *exspec) {
 }
 
 static FuncArg *CPrec_GetArgListPatch(FuncArg *lst, Boolean includeNames) {
-    // too many register swaps
-    AddrPatch *addrPatch;
     FuncArg *first, *current, *next;
+    AddrPatch *addrPatch;
 
     if ((addrPatch = CPrec_FindAddrPatch(lst)))
         return addrPatch->value;
 
     first = current = CPrec_AppendAlign();
-restart:
-    if (!includeNames)
-        lst->name = NULL;
-    CPrec_AppendData(lst, sizeof(FuncArg));
-    if (includeNames && lst->name)
-        CPrec_NamePatch(&current->name, lst->name);
-
-    if (lst->dexpr)
-        CPrec_NewPointerPatch(&current->dexpr, CPrec_GetExpressionPatch(lst->dexpr));
-    if (lst->type)
-        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(lst->type));
-    else
-#line 1167
-        CError_FATAL();
+    while (1) {
+        if (!includeNames)
+            lst->name = NULL;
+        CPrec_AppendData(lst, sizeof(FuncArg));
+        if (includeNames && lst->name)
+            CPrec_NamePatch(&current->name, lst->name);
+
+        if (lst->dexpr)
+            CPrec_NewPointerPatch(&current->dexpr, CPrec_GetExpressionPatch(lst->dexpr));
+        if (lst->type)
+            CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(lst->type));
+        else
+            CError_FATAL(1167);
+
+        if (!lst->next)
+            break;
 
-    if (lst->next) {
         if ((addrPatch = CPrec_FindAddrPatch(lst->next))) {
             CPrec_NewPointerPatch(&current->next, addrPatch->value);
-        } else {
-            next = CPrec_AppendAlign();
-            CPrec_NewPointerPatch(&current->next, next);
-            current = next;
-            lst = lst->next;
-            CPrec_NewAddrPatch(lst, next);
-            goto restart;
+            break;
         }
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        lst = lst->next;
+        CPrec_NewAddrPatch(lst, next);
     }
 
     return first;
@@ -670,8 +927,7 @@ static TypeTemplDep *CPrec_GetTypeTemplDepPatch(TypeTemplDep *type) {
             CPrec_NewPointerPatch(&p->u.bitfield.size, CPrec_GetExpressionPatch(type->u.bitfield.size));
             break;
         default:
-#line 1295
-            CError_FATAL();
+            CError_FATAL(1295);
     }
 
     return p;
@@ -817,7 +1073,7 @@ static ObjCMethodArg *CPrec_GetObjCMethodArgPatch(ObjCMethodArg *arg) {
     first = current = CPrec_AppendAlign();
 
     do {
-        CPrec_AppendData(arg, sizeof(ObjCMethodArg));
+        CPrec_AppendData(arg, sizeof(ObjCMethod));
         if (arg->selector)
             CPrec_NamePatch(&current->selector, arg->selector);
         if (arg->name)
@@ -1087,8 +1343,7 @@ static TemplArg *CPrec_GetTemplateArgPatch(TemplArg *arg) {
                     CPrec_NewPointerPatch(&current->data.ttargtype, CPrec_GetTypePatch(arg->data.ttargtype));
                 break;
             default:
-#line 1879
-                CError_FATAL();
+                CError_FATAL(1879);
         }
 
         if (!arg->next)
@@ -1125,12 +1380,10 @@ static TemplParam *CPrec_GetTemplateParamPatch(TemplParam *param) {
             case TPT_TEMPLATE:
                 if (param->data.templparam.plist)
                     CPrec_NewPointerPatch(&current->data.templparam.plist, CPrec_GetTemplateParamPatch(param->data.templparam.plist));
-#line 1953
-                CError_ASSERT(!param->data.templparam.defaultarg);
+                CError_ASSERT(1953, !param->data.templparam.defaultarg);
                 break;
             default:
-#line 1958
-                CError_FATAL();
+                CError_FATAL(1958);
         }
 
         if (!param->next)
@@ -1206,8 +1459,7 @@ static TStreamElement *CPrec_GetTStreamPatch(TStreamElement *tokens, SInt32 coun
                 break;
             default:
                 if (tokens->tokentype < 0)
-#line 2063
-                    CError_FATAL();
+                    CError_FATAL(2063);
         }
         x++;
         tokens++;
@@ -1361,8 +1613,7 @@ static TemplateAction *CPrec_GetTemplateActionPatch(TemplateAction *act) {
                 CPrec_NewPointerPatch(&current->u.refobj, CPrec_GetObjBasePatch(act->u.refobj));
                 break;
             default:
-#line 2410
-                CError_FATAL();
+                CError_FATAL(2410);
         }
 
         if (!act->next)
@@ -1549,8 +1800,7 @@ static Type *CPrec_GetTypePatch(Type *type) {
         case TYPEOBJCID:
         case TYPETEMPLDEPEXPR:
         default:
-#line 2796
-            CError_FATAL();
+            CError_FATAL(2796);
             return NULL;
     }
 }
@@ -1619,8 +1869,7 @@ repeat:
         case EAT_TERMINATE:
             break;
         default:
-#line 2905
-            CError_FATAL();
+            CError_FATAL(2905);
     }
 
     if (exc->prev) {
@@ -1652,17 +1901,247 @@ static ENodeList *CPrec_GetExpressionListPatch(ENodeList *lst) {
     return first;
 }
 
-static void CPrec_GetEMemberInfoPatch() {}
+static EMemberInfo *CPrec_GetEMemberInfoPatch(EMemberInfo *emember) {
+    EMemberInfo *p;
+
+    CError_FATAL(2953);
+
+    p = CPrec_AppendAlign();
+    CPrec_AppendData(emember, sizeof(EMemberInfo));
+
+    if (emember->path)
+        CPrec_NewPointerPatch(&p->path, CPrec_GetClassAccessPatch(emember->path));
+    if (emember->expr)
+        CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(emember->expr));
+    CError_ASSERT(2968, !emember->templargs);
+    CPrec_NewPointerPatch(&p->list, CPrec_GetNameSpaceObjectListPatch(emember->list));
+
+    return p;
+}
+
+static ENode *CPrec_GetExpressionPatch(ENode *expr) {
+    ENode *p;
+
+    if (ENODE_IS(expr, ETEMPLDEP) && expr->data.templdep.subtype == TDE_SOURCEREF)
+        expr->data.templdep.u.sourceref.token = NULL;
+
+    p = CPrec_AppendAlign();
+    CPrec_AppendData(expr, sizeof(ENode));
+
+    CPrec_NewPointerPatch(&p->rtype, CPrec_GetTypePatch(expr->rtype));
+
+    switch (expr->type) {
+        ENODE_CASE_MONADIC:
+            CPrec_NewPointerPatch(&p->data.monadic, CPrec_GetExpressionPatch(expr->data.monadic));
+            break;
+        ENODE_CASE_DIADIC_ALL:
+            CPrec_NewPointerPatch(&p->data.diadic.left, CPrec_GetExpressionPatch(expr->data.diadic.left));
+            CPrec_NewPointerPatch(&p->data.diadic.right, CPrec_GetExpressionPatch(expr->data.diadic.right));
+            break;
+        case ECOND:
+            CPrec_NewPointerPatch(&p->data.cond.cond, CPrec_GetExpressionPatch(expr->data.cond.cond));
+            CPrec_NewPointerPatch(&p->data.cond.expr1, CPrec_GetExpressionPatch(expr->data.cond.expr1));
+            CPrec_NewPointerPatch(&p->data.cond.expr2, CPrec_GetExpressionPatch(expr->data.cond.expr2));
+            break;
+        case ESTRINGCONST:
+            CPrec_RawMemPatch(&p->data.string.data, expr->data.string.data, expr->data.string.size);
+            break;
+        case EOBJREF:
+            CPrec_NewPointerPatch(&p->data.objref, CPrec_GetObjectPatch(expr->data.objref));
+            break;
+        case EOBJLIST:
+            CPrec_NewPointerPatch(&p->data.objlist.list, CPrec_GetNameSpaceObjectListPatch(expr->data.objlist.list));
+            CError_ASSERT(3043, !expr->data.objlist.templargs);
+            if (expr->data.objlist.name)
+                CPrec_NamePatch(&p->data.objlist.name, expr->data.objlist.name);
+            break;
+        case EMFPOINTER:
+            CPrec_NewPointerPatch(&p->data.mfpointer.accessnode, CPrec_GetExpressionPatch(expr->data.mfpointer.accessnode));
+            CPrec_NewPointerPatch(&p->data.mfpointer.mfpointer, CPrec_GetExpressionPatch(expr->data.mfpointer.mfpointer));
+            break;
+        case ENULLCHECK:
+            CPrec_NewPointerPatch(&p->data.nullcheck.nullcheckexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.nullcheckexpr));
+            CPrec_NewPointerPatch(&p->data.nullcheck.condexpr, CPrec_GetExpressionPatch(expr->data.nullcheck.condexpr));
+            break;
+        case ETEMP:
+            CPrec_NewPointerPatch(&p->data.temp.type, CPrec_GetTypePatch(expr->data.temp.type));
+            break;
+        case EFUNCCALL:
+        case EFUNCCALLP:
+            CPrec_NewPointerPatch(&p->data.funccall.funcref, CPrec_GetExpressionPatch(expr->data.funccall.funcref));
+            CPrec_NewPointerPatch(&p->data.funccall.functype, CPrec_GetTypePatch(TYPE(expr->data.funccall.functype)));
+            if (expr->data.funccall.args)
+                CPrec_NewPointerPatch(&p->data.funccall.args, CPrec_GetExpressionListPatch(expr->data.funccall.args));
+            break;
+        case EMEMBER:
+            CPrec_NewPointerPatch(&p->data.emember, CPrec_GetEMemberInfoPatch(expr->data.emember));
+            break;
+        case ETEMPLDEP:
+            switch (expr->data.templdep.subtype) {
+                case TDE_PARAM:
+                    break;
+                case TDE_SIZEOF:
+                case TDE_ALIGNOF:
+                    CPrec_NewPointerPatch(&p->data.templdep.u.typeexpr.type, CPrec_GetTypePatch(expr->data.templdep.u.typeexpr.type));
+                    break;
+                case TDE_CAST:
+                    if (expr->data.templdep.u.cast.args)
+                        CPrec_NewPointerPatch(&p->data.templdep.u.cast.args, CPrec_GetExpressionListPatch(expr->data.templdep.u.cast.args));
+                    CPrec_NewPointerPatch(&p->data.templdep.u.cast.type, CPrec_GetTypePatch(expr->data.templdep.u.cast.type));
+                    break;
+                case TDE_QUALNAME:
+                    CPrec_NamePatch(&p->data.templdep.u.qual.name, expr->data.templdep.u.qual.name);
+                    CPrec_NewPointerPatch(&p->data.templdep.u.qual.type, CPrec_GetTypePatch(TYPE(expr->data.templdep.u.qual.type)));
+                    break;
+                case TDE_OBJ:
+                    CPrec_NewPointerPatch(&p->data.templdep.u.obj, CPrec_GetObjectPatch(expr->data.templdep.u.obj));
+                    break;
+                case TDE_SOURCEREF:
+                    CPrec_NewPointerPatch(&p->data.templdep.u.sourceref.expr, CPrec_GetExpressionPatch(expr->data.templdep.u.sourceref.expr));
+                    break;
+                case TDE_ADDRESS_OF:
+                    CPrec_NewPointerPatch(&p->data.templdep.u.monadic, CPrec_GetExpressionPatch(expr->data.templdep.u.monadic));
+                    break;
+                default:
+                    CError_FATAL(3136);
+            }
+            break;
+        case EINTCONST:
+        case EFLOATCONST:
+        case EPRECOMP:
+        case EARGOBJ:
+        case ELOCOBJ:
+        case ELABEL:
+        case EINSTRUCTION:
+        case EVECTOR128CONST:
+            break;
+        default:
+            CError_FATAL(3142);
+    }
+
+    return p;
+}
+
+static CI_Switch *CPrec_GetSwitchInfoPatch(CI_Switch *si) {
+    CI_Switch *p = CPrec_AppendAlign();
+    CPrec_AppendData(si, sizeof(CI_Switch) + sizeof(CI_SwitchCase) * (si->numcases - 1));
+
+    CPrec_NewPointerPatch(&p->expr, CPrec_GetExpressionPatch(si->expr));
+    CPrec_NewPointerPatch(&p->unkSwitch8, CPrec_GetTypePatch(si->unkSwitch8));
+    return p;
+}
+
+static InlineAsm *CPrec_GetInlineAsmPatch(InlineAsm *ia, SInt32 size) {
+    InlineAsm *p;
+    SInt32 index;
+    SInt32 offset;
+    Object *object;
+
+    p = CPrec_AppendAlign();
+    CPrec_AppendData(ia, size);
+
+    index = 0;
+    while (1) {
+        object = InlineAsm_GetObjectOffset(ia, index, &offset);
+        if (!object)
+            break;
+
+        object = CPrec_GetObjectPatch(object);
+        CPrec_NewPointerPatch((char *) p + offset, object);
+        index++;
+    }
+
+    return p;
+}
+
+static CI_Statement *CPrec_GetStatementPatch(CI_Statement *stmt, short count) {
+    short i;
+    CI_Statement *first, *current;
+
+    for (i = 0; i < count; i++) {
+        stmt[i].sourcefilepath = NULL;
+        stmt[i].sourceoffset = -1;
+    }
+
+    first = current = CPrec_AppendAlign();
+    CPrec_AppendData(stmt, sizeof(CI_Statement) * count);
+
+    for (i = 0; i < count; i++) {
+        if (stmt->dobjstack)
+            CPrec_NewPointerPatch(&current->dobjstack, CPrec_GetExceptionPatch(stmt->dobjstack));
+
+        switch (stmt->type) {
+            case ST_EXPRESSION:
+            case ST_RETURN:
+            case ST_BEGINCATCH:
+            case ST_ENDCATCH:
+            case ST_ENDCATCHDTOR:
+                if (stmt->u.expr)
+                    CPrec_NewPointerPatch(&current->u.expr, CPrec_GetExpressionPatch(stmt->u.expr));
+                break;
+            case ST_IFGOTO:
+            case ST_IFNGOTO:
+                CPrec_NewPointerPatch(&current->u.ifgoto.expr, CPrec_GetExpressionPatch(stmt->u.ifgoto.expr));
+                break;
+            case ST_SWITCH:
+                CPrec_NewPointerPatch(&current->u.switchdata, CPrec_GetSwitchInfoPatch(stmt->u.switchdata));
+                break;
+            case ST_ASM:
+                CPrec_NewPointerPatch(&current->u.asmdata.data, CPrec_GetInlineAsmPatch(stmt->u.asmdata.data, stmt->u.asmdata.size));
+                break;
+            case ST_NOP:
+            case ST_LABEL:
+            case ST_GOTO:
+                break;
+            default:
+                CError_FATAL(3261);
+        }
+
+        current++;
+        stmt++;
+    }
+
+    return first;
+}
+
+static CI_Var *CPrec_GetLocObjectPatch(CI_Var *obj, short count) {
+    CI_Var *first, *current;
+    short i;
 
-static ENode *CPrec_GetExpressionPatch(ENode *enode) {
+    first = current = CPrec_AppendAlign();
+    CPrec_AppendData(obj, sizeof(CI_Var) * count);
+
+    for (i = 0; i < count; i++) {
+        CPrec_NamePatch(&current->name, obj->name);
+        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(obj->type));
+        current++;
+        obj++;
+    }
 
+    return first;
 }
 
-static void CPrec_GetSwitchInfoPatch() {}
-static void CPrec_GetInlineAsmPatch() {}
-static void CPrec_GetStatementPatch() {}
-static void CPrec_GetLocObjectPatch() {}
-static void CPrec_GetInlineFuncPatch() {}
+static CI_FuncData *CPrec_GetInlineFuncPatch(CI_FuncData *ifunc) {
+    CI_FuncData *p;
+
+    memclrw(&ifunc->fileoffset, sizeof(FileOffsetInfo));
+    ifunc->symdecloffset = 0;
+    ifunc->functionbodyoffset = 0;
+    ifunc->functionbodypath = NULL;
+    ifunc->symdeclend = 0;
+
+    p = CPrec_AppendAlign();
+    CPrec_AppendData(ifunc, sizeof(CI_FuncData));
+
+    if (ifunc->numarguments)
+        CPrec_NewPointerPatch(&p->arguments, CPrec_GetLocObjectPatch(ifunc->arguments, ifunc->numarguments));
+    if (ifunc->numlocals)
+        CPrec_NewPointerPatch(&p->locals, CPrec_GetLocObjectPatch(ifunc->locals, ifunc->numlocals));
+    if (ifunc->numstatements)
+        CPrec_NewPointerPatch(&p->statements, CPrec_GetStatementPatch(ifunc->statements, ifunc->numstatements));
+
+    return p;
+}
 
 static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj) {
     AddrPatch *addrPatch;
@@ -1677,8 +2156,7 @@ static ObjEnumConst *CPrec_GetObjEnumConstPatch(ObjEnumConst *obj) {
     do {
         CPrec_AppendData(obj, sizeof(ObjEnumConst));
         if (cprec_dowrite) {
-#line 3349
-            CError_ASSERT(obj->access != 255);
+            CError_ASSERT(3349, obj->access != 255);
             obj->access = 255;
         }
         CPrec_NamePatch(&current->name, obj->name);
@@ -1744,8 +2222,48 @@ static ObjNameSpace *CPrec_GetObjNameSpacePatch(ObjNameSpace *obj) {
     return p;
 }
 
-static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *obj) {
+static ObjMemberVar *CPrec_GetObjMemberVarPatch(ObjMemberVar *ivar) {
+    AddrPatch *addrPatch;
+    ObjMemberVar *first, *current, *next;
+
+    if ((addrPatch = CPrec_FindAddrPatch(ivar)))
+        return addrPatch->value;
+
+    first = current = CPrec_AppendAlign();
+    CPrec_NewAddrPatch(ivar, first);
+
+    while (1) {
+        if (ivar->has_path) {
+            CPrec_AppendData(ivar, sizeof(ObjMemberVarPath));
+            if (OBJ_MEMBER_VAR_PATH(ivar)->path)
+                CPrec_NewPointerPatch(
+                    &OBJ_MEMBER_VAR_PATH(current)->path,
+                    CPrec_GetClassAccessPatch(OBJ_MEMBER_VAR_PATH(ivar)->path));
+        } else {
+            CPrec_AppendData(ivar, sizeof(ObjMemberVar));
+        }
 
+        if (ivar->name)
+            CPrec_NamePatch(&current->name, ivar->name);
+        CPrec_NewPointerPatch(&current->type, CPrec_GetTypePatch(ivar->type));
+
+        if (!ivar->next)
+            break;
+
+        if ((addrPatch = CPrec_FindAddrPatch(ivar->next))) {
+            CPrec_NewPointerPatch(&current->next, addrPatch->value);
+            break;
+        }
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+
+        current = next;
+        ivar = ivar->next;
+        CPrec_NewAddrPatch(ivar, current);
+    }
+
+    return first;
 }
 
 static DefArgCtorInfo *CPrec_GetDefArgCtorInfoPatch(DefArgCtorInfo *dac) {
@@ -1775,15 +2293,102 @@ static InlineXRef *CPrec_GetInlineXRefPatch(InlineXRef *ix) {
     return first;
 }
 
-static Object *CPrec_GetObjectPatch(Object *o) {
+static Object *CPrec_GetObjectPatch(Object *obj) {
+    AddrPatch *addrPatch;
+    Object *p;
+
+    if (CWUserBreak(cparams.context) != cwNoErr)
+        CError_UserBreak();
+
+    if ((addrPatch = CPrec_FindAddrPatch(obj)))
+        return addrPatch->value;
+
+    p = CPrec_AppendAlign();
+    CPrec_NewAddrPatch(obj, p);
+
+    obj->toc = NULL;
+
+    if ((obj->qual & Q_400000) && obj->datatype != DALIAS) {
+        CPrec_AppendData(obj, sizeof(ObjectTemplated));
+        CPrec_NewPointerPatch(&OBJECT_TEMPL(p)->parent, CPrec_GetObjectPatch(OBJECT_TEMPL(obj)->parent));
+    } else {
+        CPrec_AppendData(obj, sizeof(Object));
+    }
+
+    if (obj->nspace)
+        CPrec_NewPointerPatch(&p->nspace, CPrec_GetNameSpacePatch(obj->nspace));
+    if (obj->name)
+        CPrec_NamePatch(&p->name, obj->name);
+    CPrec_NewPointerPatch(&p->type, CPrec_GetTypePatch(obj->type));
+
+    switch (obj->datatype) {
+        case DABSOLUTE:
+            break;
+
+        case DLOCAL:
+            CError_FATAL(3580);
+            break;
+
+        case DFUNC:
+        case DVFUNC:
+            if (IS_TEMPL_FUNC(obj->type))
+                CPrec_NewPointerPatch(&p->u.func.u.templ, CPrec_GetTemplateFunctionPatch(obj->u.func.u.templ));
+            else if ((obj->qual & Q_INLINE) && obj->u.func.u.ifuncdata)
+                CPrec_NewPointerPatch(&p->u.func.u.ifuncdata, CPrec_GetInlineFuncPatch(obj->u.func.u.ifuncdata));
+
+            if (obj->u.func.defargdata)
+                CPrec_NewPointerPatch(&p->u.func.defargdata, CPrec_GetDefArgCtorInfoPatch(obj->u.func.defargdata));
+            if (obj->u.func.linkname)
+                CPrec_NamePatch(&p->u.func.linkname, obj->u.func.linkname);
+            if (obj->u.func.inst)
+                CPrec_NewPointerPatch(&p->u.func.inst, CPrec_GetTemplFuncInstancePatch(obj->u.func.inst));
+            break;
+
+        case DDATA:
+            CError_ASSERT(3622, !obj->u.data.info);
+            if (obj->qual & Q_10000) {
+                switch (obj->type->type) {
+                    case TYPEINT:
+                    case TYPEENUM:
+                    case TYPEPOINTER:
+                        break;
+                    case TYPEFLOAT:
+                        CPrec_RawMemPatch(&p->u.data.u.floatconst, obj->u.data.u.floatconst, sizeof(Float));
+                        break;
+                    default:
+                        CError_FATAL(3638);
+                }
+            }
+            if (obj->u.data.linkname)
+                CPrec_NamePatch(&p->u.data.linkname, obj->u.data.linkname);
+            break;
+
+        case DINLINEFUNC:
+            CPrec_RawMemPatch(&p->u.ifunc.data, obj->u.ifunc.data, obj->u.ifunc.size);
+            if (obj->u.ifunc.xrefs)
+                CPrec_NewPointerPatch(&p->u.ifunc.xrefs, CPrec_GetInlineXRefPatch(obj->u.ifunc.xrefs));
+            break;
+
+        case DALIAS:
+            CPrec_NewPointerPatch(&p->u.alias.object, CPrec_GetObjectPatch(obj->u.alias.object));
+            if (obj->u.alias.member)
+                CPrec_NewPointerPatch(&p->u.alias.member, CPrec_GetClassAccessPatch(obj->u.alias.member));
+            break;
+
+        default:
+            CError_FATAL(3677);
+    }
+
+    if (cprec_dowrite)
+        obj->datatype = -1;
 
+    return p;
 }
 
 static ObjBase *CPrec_GetObjBasePatch(ObjBase *obj) {
     switch (obj->otype) {
         default:
-#line 3694
-            CError_FATAL();
+            CError_FATAL(3694);
         case OT_ENUMCONST:
             return (ObjBase *) CPrec_GetObjEnumConstPatch((ObjEnumConst *) obj);
         case OT_TYPE:
@@ -1945,16 +2550,217 @@ static NameSpace *CPrec_GetNameSpacePatch(NameSpace *nspace) {
     return p;
 }
 
-static void CPrec_DumpRootNameSpace() {}
-static void CPrec_GetSOMPatch() {}
-static void CPrec_GetOLinkPatch() {}
-static void CPrec_GetStaticDataPatch() {}
-static void CPrec_GetCallbackPatch() {}
-static void CPrec_GetSelHashTablePatch() {}
-static void CPrec_GetIExpressionPatch() {}
-static void CPrec_GetInlineActionPatch() {}
+static void CPrec_DumpRootNameSpace(void) {
+    NameSpaceList *nslist;
+    NameSpaceName *nsname;
+    int i;
+
+    CError_ASSERT(3905, cscope_root->is_hash);
+
+    if (cscope_root->usings) {
+        nslist = CPrec_GetNameSpaceListPatch(cscope_root->usings);
+        if (cprec_dowrite)
+            cprec_header->usings = nslist;
+    }
+
+    if (cprec_dowrite)
+        cprec_header->root_names = cscope_root->names;
+
+    i = 0;
+    do {
+        if (cscope_root->data.hash[i]) {
+            nsname = CPrec_GetNameSpaceNamePatch(cscope_root->data.hash[i], 1);
+            if (cprec_dowrite) {
+                if (cprec_ioerror != noErr)
+                    break;
+                cprec_header->root_nametable[i] = nsname;
+            }
+        }
+    } while (++i < 0x400);
+}
+
+static CSOMStub *CPrec_GetSOMPatch(CSOMStub *stub) {
+    CSOMStub *first, *current, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        CPrec_AppendData(stub, sizeof(CSOMStub));
+
+        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(stub->object));
+        CPrec_NewPointerPatch(&current->tclass, CPrec_GetTypePatch(TYPE(stub->tclass)));
+
+        if (!stub->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        stub = stub->next;
+    }
+
+    return first;
+}
+
+static OLinkList *CPrec_GetOLinkPatch(OLinkList *olink) {
+    OLinkList *first, *current, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        CPrec_AppendData(olink, sizeof(OLinkList));
+
+        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(olink->obj));
+
+        if (!olink->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        olink = olink->next;
+    }
+
+    return first;
+}
+
+static StaticData *CPrec_GetStaticDataPatch(StaticData *sd) {
+    StaticData *current, *first, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        CPrec_AppendData(sd, sizeof(StaticData));
+
+        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(sd->object));
+        if (sd->buffer)
+            CPrec_RawMemPatch(&current->buffer, sd->buffer, sd->object->type->size);
+        if (sd->links)
+            CPrec_NewPointerPatch(&current->links, CPrec_GetOLinkPatch(sd->links));
+
+        if (!sd->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        sd = sd->next;
+    }
+
+    return first;
+}
+
+static CallbackAction *CPrec_GetCallbackPatch(CallbackAction *ca) {
+    CallbackAction *first, *current, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        CPrec_AppendData(ca, sizeof(CallbackAction));
+
+        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(ca->obj));
+        CPrec_NewPointerPatch(&current->tclass, CPrec_GetTypePatch(TYPE(ca->tclass)));
+
+        if (!ca->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        ca = ca->next;
+    }
+
+    return first;
+}
+
+static ObjCSelector **CPrec_GetSelHashTablePatch(ObjCSelector **table) {
+    ObjCSelector **first, **current;
+    int i;
+
+    first = current = CPrec_AppendAlign();
+    CPrec_AppendData(table, sizeof(ObjCSelector *) * 0x400);
+
+    for (i = 0; i < 0x400; i++) {
+        if (*table)
+            CPrec_NewPointerPatch(current, CPrec_GetObjCSelectorPatch(*table));
+        table++;
+        current++;
+    }
+
+    return first;
+}
+
+static InitExpr *CPrec_GetIExpressionPatch(InitExpr *initexpr) {
+    InitExpr *first, *current, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        CPrec_AppendData(initexpr, sizeof(InitExpr));
+
+        CPrec_NewPointerPatch(&current->object, CPrec_GetObjectPatch(initexpr->object));
+        CPrec_NewPointerPatch(&current->expr, CPrec_GetExpressionPatch(initexpr->expr));
+
+        if (!initexpr->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        initexpr = initexpr->next;
+    }
+
+    return first;
+}
+
+static CI_Action *CPrec_GetInlineActionPatch(CI_Action *act) {
+    CI_Action *current, *first, *next;
+
+    first = current = CPrec_AppendAlign();
+    while (1) {
+        if (act->actiontype == CI_ActionInlineFunc)
+            memclrw(&act->u.inlinefunc.fileoffset, sizeof(FileOffsetInfo));
+
+        CPrec_AppendData(act, sizeof(CI_Action));
+
+        CPrec_NewPointerPatch(&current->obj, CPrec_GetObjectPatch(act->obj));
+
+        switch (act->actiontype) {
+            case CI_ActionInlineFunc:
+                if (act->u.inlinefunc.stream.firsttoken)
+                    CPrec_NewPointerPatch(
+                        &current->u.inlinefunc.stream.firsttoken,
+                        CPrec_GetTStreamPatch(act->u.inlinefunc.stream.firsttoken, act->u.inlinefunc.stream.tokens));
+                if (act->u.inlinefunc.tclass)
+                    CPrec_NewPointerPatch(&current->u.inlinefunc.tclass, CPrec_GetTypePatch(TYPE(act->u.inlinefunc.tclass)));
+                break;
+
+            case CI_ActionMemberFunc:
+                CPrec_NewPointerPatch(&current->u.memberfunc.templ, CPrec_GetTypePatch(TYPE(act->u.memberfunc.templ)));
+                CPrec_NewPointerPatch(&current->u.memberfunc.inst, CPrec_GetTypePatch(TYPE(act->u.memberfunc.inst)));
+                CPrec_NewPointerPatch(&current->u.memberfunc.tmemb, CPrec_GetTemplateMemberPatch(act->u.memberfunc.tmemb));
+                break;
+
+            case CI_ActionTemplateFunc:
+                CPrec_NewPointerPatch(&current->u.templatefunc.func, CPrec_GetTemplateFunctionPatch(act->u.templatefunc.func));
+                CPrec_NewPointerPatch(&current->u.templatefunc.inst, CPrec_GetTemplFuncInstancePatch(act->u.templatefunc.inst));
+                break;
+
+            case CI_ActionDefaultFunc:
+                break;
+
+            default:
+                CError_FATAL(4177);
+        }
+
+        if (!act->next)
+            break;
+
+        next = CPrec_AppendAlign();
+        CPrec_NewPointerPatch(&current->next, next);
+        current = next;
+        act = act->next;
+    }
+
+    return first;
+}
 
-static void CPrec_GenerateBuiltinPatches() {
+static void CPrec_GenerateBuiltinPatches(void) {
     int x;
     int y;
     Patch *scan;
@@ -1975,7 +2781,7 @@ static void CPrec_GenerateBuiltinPatches() {
     CPrec_AppendWord32(0);
 }
 
-static void CPrec_GenerateTokenStreamPatches() {
+static void CPrec_GenerateTokenStreamPatches(void) {
     TokenPatch *scan;
 
     for (scan = cprec_tokenpatches; scan; scan = scan->next) {
@@ -2032,7 +2838,7 @@ static OSErr CPrec_CompressWrite(const char *data, SInt32 size) {
     return noErr;
 }
 
-static OSErr CPrec_FlushRawBuffer() {
+static OSErr CPrec_FlushRawBuffer(void) {
     OSErr err;
 
     if (cprec_dowrite) {
@@ -2049,7 +2855,7 @@ static OSErr CPrec_FlushRawBuffer() {
     }
 }
 
-static OSErr CPrec_FlushBufferCheck() {
+static OSErr CPrec_FlushBufferCheck(void) {
     static SInt32 flushmax;
     OSErr err;
 
@@ -2067,7 +2873,7 @@ static OSErr CPrec_FlushBufferCheck() {
     return noErr;
 }
 
-static int CPrec_CompressPatches() {
+static int CPrec_CompressPatches(void) {
     Patch *scan;
     int count;
     SInt32 last;
@@ -2078,8 +2884,7 @@ static int CPrec_CompressPatches() {
     last = 0;
     count = 0;
     while (scan) {
-#line 4339
-        CError_ASSERT((scan->offset & 0x80000001) == 0);
+        CError_ASSERT(4339, (scan->offset & 0x80000001) == 0);
 
         if ((scan->offset - last) >= -128 && (scan->offset - last) <= 126)
             CPrec_AppendByte(((scan->offset - last) >> 1) | 0x80);
@@ -2094,7 +2899,146 @@ static int CPrec_CompressPatches() {
     return count;
 }
 
-static void CPrec_DumpColorSymbolTable() {}
+static OSErr CPrec_DumpColorSymbolTable(Boolean doWrite) {
+    OSErr err;
+
+    freelheap();
+
+    CPrec_InitAddressHashTable();
+    CPrec_InitPointerHashTable();
+
+    cprec_patch_list = NULL;
+    cprec_tokenpatches = NULL;
+    cprec_offset = 0;
+    cprec_zero_offset = 0;
+    cprec_dowrite = doWrite;
+    cprec_ioerror = noErr;
+
+    CPrec_SetupBuiltIn();
+    CPrec_AppendWord32(0);
+
+    CPrec_DumpNameTable();
+    if ((err = CPrec_FlushRawBuffer()) != noErr)
+        return err;
+
+    CPrec_DumpMacroTable();
+    if ((err = CPrec_FlushRawBuffer()) != noErr)
+        return err;
+
+    CPrec_DumpRootNameSpace();
+    if (doWrite) {
+        if (cprec_ioerror != noErr)
+            return cprec_ioerror;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (ctempl_templates) {
+        TemplClass *p = TEMPL_CLASS(CPrec_GetTypePatch(TYPE(ctempl_templates)));
+        if (doWrite)
+            cprec_header->ctempl_templates = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (ctempl_templatefuncs) {
+        TemplateFunction *p = CPrec_GetTemplateFunctionPatch(ctempl_templatefuncs);
+        if (doWrite)
+            cprec_header->ctempl_templatefuncs = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (csom_stubs) {
+        CSOMStub *p = CPrec_GetSOMPatch(csom_stubs);
+        if (doWrite)
+            cprec_header->csom_stubs = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cprec_staticdata) {
+        StaticData *p = CPrec_GetStaticDataPatch(cprec_staticdata);
+        if (doWrite)
+            cprec_header->cprec_staticdata = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (callbackactions) {
+        CallbackAction *p = CPrec_GetCallbackPatch(callbackactions);
+        if (doWrite)
+            cprec_header->callbackactions = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_type_class) {
+        Type *p = CPrec_GetTypePatch(cobjc_type_class);
+        if (doWrite)
+            cprec_header->cobjc_type_class = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_type_id) {
+        Type *p = CPrec_GetTypePatch(cobjc_type_id);
+        if (doWrite)
+            cprec_header->cobjc_type_id = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_type_sel) {
+        Type *p = CPrec_GetTypePatch(cobjc_type_sel);
+        if (doWrite)
+            cprec_header->cobjc_type_sel = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_selhashtable) {
+        ObjCSelector **p = CPrec_GetSelHashTablePatch(cobjc_selhashtable);
+        if (doWrite)
+            cprec_header->cobjc_selhashtable = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_classdefs) {
+        BClassList *p = CPrec_GetBClassListPatch(cobjc_classdefs);
+        if (doWrite)
+            cprec_header->cobjc_classdefs = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cobjc_protocols) {
+        ObjCProtocol *p = CPrec_GetObjCProtocolPatch(cobjc_protocols);
+        if (doWrite)
+            cprec_header->cobjc_protocols = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (init_expressions) {
+        InitExpr *p = CPrec_GetIExpressionPatch(init_expressions);
+        if (doWrite)
+            cprec_header->init_expressions = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    if (cinline_tactionlist) {
+        CI_Action *p = CPrec_GetInlineActionPatch(cinline_tactionlist);
+        if (doWrite)
+            cprec_header->cinline_tactionlist = p;
+        if ((err = CPrec_FlushRawBuffer()) != noErr)
+            return err;
+    }
+
+    return noErr;
+}
 
 static OSErr CPrec_FileAlign(short refnum, SInt32 *len) {
     OSErr err;
@@ -2112,21 +3056,341 @@ static OSErr CPrec_FileAlign(short refnum, SInt32 *len) {
     return err;
 }
 
-static void CPrec_WriteFile() {}
+static OSErr CPrec_WriteFile(void) {
+    char str[128];
+    int i;
+    HashNameNode *name;
+    OSErr err;
+    SInt32 offset;
+
+    if (InitGList(&cprec_glist, 0x40000))
+        CError_NoMem();
+
+    CompilerGetCString(10, str);
+    CWShowStatus(cparams.context, str, "");
+    CPrep_RemoveSpecialMacros();
+
+    for (i = 0; i < 0x800; i++) {
+        for (name = name_hash_nodes[i]; name; name = name->next)
+            name->id = 0;
+    }
+
+    if ((err = CPrec_DumpColorSymbolTable(0)) != noErr)
+        return err;
+
+    CompilerGetCString(11, str);
+    CWShowStatus(cparams.context, str, "");
+
+    cprec_header = galloc(sizeof(Header));
+    memclrw(cprec_header, sizeof(Header));
+
+    cprec_header->magic = 0xBEEFFACE;
+    cprec_header->version = 1047;
+    cprec_header->target = 2;
+    cprec_header->check_header_flags = copts.check_header_flags;
+    cprec_header->cplusplus = copts.cplusplus;
+    cprec_header->uniqueID = CParser_GetUniqueID();
+    cprec_header->cobjc_selrefcount = cobjc_selrefcount;
+    cprec_header->cobjc_classrefcount = cobjc_classrefcount;
+    cprec_header->cobjc_stringcount = cobjc_stringcount;
+
+    if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
+        return err;
+
+    offset = sizeof(Header);
+
+    if ((err = CPrec_DumpColorSymbolTable(1)) != noErr)
+        return err;
+
+    cprec_header->x28 = cprec_offset;
+    cprec_header->x30 = offset;
+
+    if ((err = COS_FileGetPos(cprec_refnum, &offset)) != noErr)
+        return err;
+
+    cprec_header->x2C = offset - cprec_header->x30;
+
+    cprec_header->compressedPatchCount = CPrec_CompressPatches();
+    cprec_header->compressedPatchSize = cprec_glist.size;
+    cprec_header->compressedPatchOffset = offset;
+
+    if (cprec_header->compressedPatchCount) {
+        if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+            return err;
+        offset += cprec_glist.size;
+    }
+
+    if ((err = CPrec_FileAlign(cprec_refnum, &offset)) != noErr)
+        return err;
+
+    cprec_glist.size = 0;
+    CPrec_GenerateBuiltinPatches();
+    cprec_header->builtinPatchSize = cprec_glist.size;
+    cprec_header->builtinPatchOffset = offset;
+
+    if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+        return err;
+    offset += cprec_glist.size;
+
+    if (cprec_tokenpatches) {
+        cprec_glist.size = 0;
+        CPrec_GenerateTokenStreamPatches();
+        cprec_header->tokenStreamPatchSize = cprec_glist.size;
+        cprec_header->tokenStreamPatchOffset = offset;
+
+        if ((err = COS_FileWrite(cprec_refnum, *cprec_glist.data, cprec_glist.size)) != noErr)
+            return err;
+        offset += cprec_glist.size;
+    }
+
+    if ((err = COS_FileSetPos(cprec_refnum, 0)) != noErr)
+        return err;
+
+    if ((err = COS_FileWrite(cprec_refnum, cprec_header, sizeof(Header))) != noErr)
+        return err;
+
+    return noErr;
+}
+
+void PrecompilerWrite(void) {
+    OSErr err;
+    short strindex;
+    char str[128];
+    FSSpec spec;
+
+    spec = cparamblkptr->mainFileSpec;
+    if (CWGetPrecompiledHeaderSpec(cparamblkptr->context, &spec, precomp_target_str) == cwNoErr) {
+        strindex = 3;
+        err = COS_FileNew(&spec, &cprec_refnum, copts.pchCreator, copts.pchType);
+        if (err == noErr) {
+            strindex = 4;
+            err = CPrec_WriteFile();
+        }
+        CleanupPrecompiler();
+
+        if (err != noErr) {
+            CompilerGetCString(strindex, str);
+            sprintf(string, str, err);
+            CWReportMessage(cparamblkptr->context, NULL, string, NULL, messagetypeError, 0);
+        } else {
+            CWFileTime time = 0;
+            CWSetModDate(cparamblkptr->context, &spec, &time, 1);
+        }
+    }
+}
+
+static void CPrec_ReadData(SInt32 offset, void *buffer, SInt32 size) {
+    if (
+        COS_FileSetPos(cprec_refnum, offset) != noErr ||
+        COS_FileRead(cprec_refnum, buffer, size) != noErr
+        )
+        CError_ErrorTerm(CErrorStr181);
+}
+
+static void CPrec_ReadRawBuffer(void) {
+    UInt8 *buffer;
+    UInt8 *work;
+    UInt8 *end;
+    UInt32 size;
+    int ch;
+
+    if (!cprec_buffer) {
+        size = cprec_header->x28 + (cprec_header->x28 >> 7) + 64;
+        buffer = galloc(size);
+        cprec_rawbuffer = buffer;
+
+        work = buffer + size - cprec_header->x2C;
+        CPrec_ReadData(cprec_header->x30, work, cprec_header->x2C);
+    } else {
+        buffer = galloc(cprec_header->x28);
+        cprec_rawbuffer = buffer;
+        work = (UInt8 *) cprec_buffer + cprec_header->x30;
+    }
+
+    end = work + cprec_header->x2C;
+
+    while (work < end) {
+        if ((ch = *(work++)) >= 0xE0) {
+            ch -= 0xE0;
+            do {
+                *(buffer++) = 0;
+            } while (--ch >= 0);
+        } else {
+            do {
+                *(buffer++) = *(work++);
+            } while (--ch >= 0);
+        }
+    }
+
+    if (work != end || buffer != RESOLVE_RAW_BUFFER(cprec_header->x28))
+        CError_ErrorTerm(CErrorStr181);
+}
+
+static void CPrec_RelocateRawBuffer(void) {
+    UInt8 *patches;
+    UInt32 offset;
+    UInt8 *dest;
+    SInt32 count;
+    UInt8 *patch;
+    UInt32 var;
+
+    if ((count = cprec_header->compressedPatchCount)) {
+        if (!cprec_buffer) {
+            patches = lalloc(cprec_header->compressedPatchSize);
+            CPrec_ReadData(cprec_header->compressedPatchOffset, patches, cprec_header->compressedPatchSize);
+        } else {
+            patches = RESOLVE_BUFFER(cprec_header->compressedPatchOffset);
+        }
+
+        offset = 0;
+        patch = patches;
+        dest = cprec_rawbuffer;
+        do {
+            if (!(*patch & 0x80)) {
+                ((UInt8 *) &var)[0] = *(patch++);
+                ((UInt8 *) &var)[1] = *(patch++);
+                ((UInt8 *) &var)[2] = *(patch++);
+                ((UInt8 *) &var)[3] = *(patch++);
+                offset = var;
+            } else {
+                offset += (char) (*(patch++) * 2);
+            }
+            *((uintptr_t *) (dest + offset)) += (uintptr_t) dest;
+        } while (--count > 0);
+
+        freelheap();
+
+        if (patch != (patches + cprec_header->compressedPatchSize))
+            CError_ErrorTerm(CErrorStr181);
+    }
+}
+
+static void CPrec_RelocateBuiltins(void) {
+    UInt32 *patches;
+    void *builtin;
+    UInt32 count;
+    UInt8 *buffer;
+
+    if (cprec_header->builtinPatchSize) {
+        CPrec_SetupBuiltInArray();
+        if (!cprec_buffer) {
+            patches = lalloc(cprec_header->builtinPatchSize);
+            CPrec_ReadData(cprec_header->builtinPatchOffset, patches, cprec_header->builtinPatchSize);
+        } else {
+            patches = RESOLVE_BUFFER(cprec_header->builtinPatchOffset);
+        }
 
-void PrecompilerWrite() {
+        buffer = cprec_rawbuffer;
+        while (1) {
+            if (!(count = *(patches++)))
+                break;
+
+            builtin = cprec_builtin_array[*(patches++)];
+            do {
+                *((void **) (buffer + *(patches++))) = builtin;
+            } while (--count);
+        }
+    }
 }
 
-static void CPrec_ReadData() {}
-static void CPrec_ReadRawBuffer() {}
-static void CPrec_RelocateRawBuffer() {}
-static void CPrec_RelocateBuiltins() {}
-static void CPrec_RelocateTokenStreams() {}
-static void CPrec_RelocateMacroTable() {}
-static void CPrec_RelocateTable() {}
-static void CPrec_RelocateRootNameSpace() {}
+static void CPrec_RelocateTokenStreams(void) {
+    UInt32 *patches;
+    UInt32 count;
+    TStreamElement *tokens;
+    UInt8 *buffer;
+    CPrepFileInfo *file;
+    SInt32 pos;
+
+    if (cprec_header->tokenStreamPatchSize) {
+        CPrep_GetPrepPos(&file, &pos);
+
+        if (!cprec_buffer) {
+            patches = lalloc(cprec_header->tokenStreamPatchSize);
+            CPrec_ReadData(cprec_header->tokenStreamPatchOffset, patches, cprec_header->tokenStreamPatchSize);
+        } else {
+            patches = RESOLVE_BUFFER(cprec_header->tokenStreamPatchOffset);
+        }
 
-static void CPrec_FixNameIds() {
+        buffer = cprec_rawbuffer;
+        while (1) {
+            if (!*patches)
+                break;
+
+            tokens = (TStreamElement *) (buffer + *(patches++));
+            count = *(patches++);
+
+            while (count--) {
+                tokens->tokenfile = file;
+                tokens->tokenoffset = pos;
+                tokens++;
+            }
+        }
+    }
+}
+
+static void CPrec_RelocateMacroTable(void) {
+    int i;
+    int j;
+    int count;
+    UInt8 *buffer;
+    Macro **prec_table;
+    Macro **table;
+    Macro *macro;
+    uintptr_t offset;
+
+    buffer = cprec_rawbuffer;
+    prec_table = cprec_header->macrotable;
+    table = macrohashtable;
+
+    i = 0;
+    do {
+        for (macro = *table; macro; macro = macro->next) {
+            macro->name = GetHashNameNodeExport(macro->name->name);
+            count = macro->xC & 0x7FFF;
+            for (j = 1; j < count; j++)
+                macro->names[j - 1] = GetHashNameNodeExport(macro->names[j - 1]->name);
+        }
+
+        if ((offset = (uintptr_t) *prec_table)) {
+            if (*table) {
+                macro = (Macro *) (buffer + offset);
+                while (macro->next)
+                    macro = macro->next;
+                macro->next = *table;
+            }
+            *table = (Macro *) (buffer + offset);
+        }
+
+        prec_table++;
+        table++;
+    } while (++i < 0x800);
+}
+
+static void CPrec_RelocateTable(void **table, int size, void **dest) {
+    int i;
+    void *buffer = cprec_rawbuffer;
+
+    for (i = 0; i < size; i++) {
+        if (*table)
+            *dest = (char *) buffer + (uintptr_t) *table;
+        else
+            *dest = NULL;
+        table++;
+        dest++;
+    }
+}
+
+static void CPrec_RelocateRootNameSpace(void) {
+    CError_ASSERT(4981, cscope_root->is_hash);
+
+    cscope_root->names = cprec_header->root_names;
+    CPrec_RelocateTable(
+        (void **) cprec_header->root_nametable,
+        0x400,
+        (void **) cscope_root->data.hash);
+}
+
+static void CPrec_FixNameIds(void) {
     int i;
     HashNameNode *node;
 
@@ -2136,7 +3400,83 @@ static void CPrec_FixNameIds() {
     }
 }
 
-static void CPrec_DefineStaticData() {}
+static void CPrec_DefineStaticData(void) {
+    StaticData *sd = cprec_staticdata;
+    cprec_staticdata = NULL;
+
+    while (sd) {
+        CInit_DeclareData(sd->object, sd->buffer, sd->links, sd->size);
+        sd = sd->next;
+    }
+}
 
 void PrecompilerRead(short refnum, void *buffer) {
+    cprec_refnum = refnum;
+    cprec_buffer = buffer;
+
+    CPrep_RemoveSpecialMacros();
+
+    if (!CScope_IsEmptySymTable())
+        CError_ErrorTerm(CErrorStr180);
+
+    if (!cprec_buffer) {
+        cprec_header = galloc(sizeof(Header));
+        CPrec_ReadData(0, cprec_header, sizeof(Header));
+    } else {
+        cprec_header = cprec_buffer;
+    }
+
+    if (cprec_header->magic != 0xBEEFFACE)
+        CError_ErrorTerm(CErrorStr181);
+    if (cprec_header->version != 1047)
+        CError_ErrorTerm(CErrorStr222);
+    if (cprec_header->target != 2)
+        CError_ErrorTerm(CErrorStr223);
+
+    copts.check_header_flags = cprec_header->check_header_flags;
+
+    CPrec_ReadRawBuffer();
+    CPrec_RelocateRawBuffer();
+    CPrec_RelocateBuiltins();
+    CPrec_RelocateTable((void **) cprec_header->nametable, 0x800, (void **) name_hash_nodes);
+    CPrec_FixNameIds();
+    CPrec_RelocateMacroTable();
+    CPrec_RelocateTokenStreams();
+    CPrec_RelocateRootNameSpace();
+
+    if (!cprec_header->usings)
+        cscope_root->usings = NULL;
+    else
+        cscope_root->usings = RESOLVE_RAW_BUFFER(cprec_header->usings);
+
+    ctempl_templates = RESOLVE_SAFE(cprec_header->ctempl_templates);
+    ctempl_templatefuncs = RESOLVE_SAFE(cprec_header->ctempl_templatefuncs);
+    csom_stubs = RESOLVE_SAFE(cprec_header->csom_stubs);
+    cprec_staticdata = RESOLVE_SAFE(cprec_header->cprec_staticdata);
+    callbackactions = RESOLVE_SAFE(cprec_header->callbackactions);
+    cobjc_type_class = RESOLVE_SAFE(cprec_header->cobjc_type_class);
+    cobjc_type_id = RESOLVE_SAFE(cprec_header->cobjc_type_id);
+    cobjc_type_sel = RESOLVE_SAFE(cprec_header->cobjc_type_sel);
+    cobjc_selhashtable = RESOLVE_SAFE(cprec_header->cobjc_selhashtable);
+    cobjc_classdefs = RESOLVE_SAFE(cprec_header->cobjc_classdefs);
+    cobjc_protocols = RESOLVE_SAFE(cprec_header->cobjc_protocols);
+    init_expressions = RESOLVE_SAFE(cprec_header->init_expressions);
+    cinline_tactionlist = RESOLVE_SAFE(cprec_header->cinline_tactionlist);
+    CParser_SetUniqueID(cprec_header->uniqueID);
+    cobjc_selrefcount = cprec_header->cobjc_selrefcount;
+    cobjc_classrefcount = cprec_header->cobjc_classrefcount;
+    cobjc_stringcount = cprec_header->cobjc_stringcount;
+
+    cprec_refnum = 0;
+
+    CleanupPrecompiler();
+    cscope_current = cscope_root;
+
+    if (!CParser_ReInitRuntimeObjects(1))
+        CError_ErrorTerm(CErrorStr181);
+
+    CPrep_InsertSpecialMacros();
+
+    if (cparamblkptr->isPrecompiling != 1)
+        CPrec_DefineStaticData();
 }
diff --git a/compiler_and_linker/unsorted/CodeGen.c b/compiler_and_linker/unsorted/CodeGen.c
index 7b73bee..8268736 100644
--- a/compiler_and_linker/unsorted/CodeGen.c
+++ b/compiler_and_linker/unsorted/CodeGen.c
@@ -7,57 +7,40 @@
 #include "compiler/CInt64.h"
 #include "compiler/CMachine.h"
 #include "compiler/CMangler.h"
+#include "compiler/COptimizer.h"
 #include "compiler/CParser.h"
 #include "compiler/CPrep.h"
 #include "compiler/CPrepTokenizer.h"
+#include "compiler/Coloring.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/uDump.h"
+#include "compiler/Exceptions.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/Intrinsics.h"
 #include "compiler/InstrSelection.h"
+#include "compiler/GlobalOptimizer.h"
+#include "compiler/ObjGenMachO.h"
 #include "compiler/Operands.h"
 #include "compiler/PCode.h"
+#include "compiler/PCodeAssembly.h"
 #include "compiler/PCodeInfo.h"
+#include "compiler/PCodeListing.h"
 #include "compiler/PCodeUtilities.h"
+#include "compiler/Peephole.h"
+#include "compiler/PPCError.h"
 #include "compiler/RegisterInfo.h"
+#include "compiler/Scheduler.h"
 #include "compiler/StackFrame.h"
+#include "compiler/Switch.h"
 #include "compiler/TOC.h"
-#include "compiler/CompilerTools.h"
+#include "compiler/ValueNumbering.h"
 #include "compiler/enode.h"
+#include "compiler/objc.h"
 #include "compiler/objects.h"
 #include "compiler/scopes.h"
 #include "compiler/tokens.h"
 #include "compiler/types.h"
 
-// TODO: MOVE ME
-extern void Intrinsics_SetupRuntimeObjects(void);
-extern void Intrinsics_ReInitRuntimeObjects(Boolean);
-extern Boolean Intrinsics_IsPublicRuntimeObject(Object *);
-extern ENode *Intrinsics_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs);
-extern void PPCError_Error(int, ...);
-extern void PPCError_Warning(int, ...);
-extern void PPCError_Message(char *, ...);
-extern void globallyoptimizepcode(Object *);
-extern void pclistblocks(char *, char *);
-extern void pclistblocks_start_scheduler(char *, char *);
-extern void pclistblocks_end_scheduler();
-extern void scheduleinstructions(Boolean);
-extern void peepholemergeblocks(Object *, Boolean);
-extern void peepholeoptimizeforward(Object *);
-extern void peepholeoptimizepcode(Object *);
-extern void colorinstructions(Object *);
-extern void removecommonsubexpressions(Object *, Boolean);
-extern int removedcommonsubexpressions;
-extern SInt32 assemblefunction(Object *, void *);
-extern void dumpswitchtables(Object *);
-extern void ObjGen_DeclareInitFunction(Object *);
-extern void *switchtables;
-extern void initializeexceptiontables();
-extern void dumpexceptiontables(Object *, SInt32);
-extern void switchstatement(ENode *, CLabel *);
-extern void DumpIR(Statement **, Object *);
-extern void InlineAsm_TranslateIRtoPCode(Statement *stmt);
-typedef struct WeirdInlineAsmThing {
-    UInt8 x0, x1, x2;
-} WeirdInlineAsmThing;
-extern Statement **COpt_Optimizer(Object *, Statement **);
-
 static Macro powcM;
 static Macro __powcM;
 static Macro ppc_cpu;
@@ -876,7 +859,7 @@ static void callprofiler(char *name) {
 static void exitprofiler(void) {
 }
 
-void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind) {
+void CodeGen_Generator(Statement *statements, Object *func, UInt8 mysteryFlag, Boolean callOnModuleBind) {
     Statement *stmt;
     Boolean has_varargs;
     PCodeBlock *tmp;
@@ -924,7 +907,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
 
     resetTOCvarinfo();
     init_registers();
-    expandTOCreferences(statements);
+    expandTOCreferences(&statements->next);
     if (copts.debuglisting)
         DumpIR(statements, func);
 
@@ -953,10 +936,10 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
     if (copts.profile)
         callprofiler(CMangler_GetLinkName(func)->name);
 
-    assign_labels(*statements);
+    assign_labels(statements->next);
     open_temp_registers();
 
-    for (stmt = *statements; stmt; stmt = stmt->next) {
+    for (stmt = statements->next; stmt; stmt = stmt->next) {
         current_statement = stmt;
         current_linenumber = stmt->sourceoffset;
         switch (stmt->type) {
@@ -991,7 +974,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
                 break;
             case ST_SWITCH:
                 newstatement(stmt->sourceoffset, stmt->value, (stmt->flags & StmtFlag_10) != 0);
-                switchstatement(stmt->expr, stmt->label);
+                switchstatement(stmt->expr, (SwitchInfo *) stmt->label);
                 break;
             case ST_BEGINCATCH:
                 capturestackpointer(stmt->expr->data.objref);
@@ -1010,8 +993,7 @@ void CodeGen_Generator(Statement **statements, Object *func, UInt8 mysteryFlag,
                 break;
             case ST_ASM:
                 if (stmt->expr) {
-                    // ... will need to understand inline ASM properly for this ...
-                    if (((WeirdInlineAsmThing *) stmt->expr)->x2 & 1) {
+                    if (((InlineAsm *) stmt->expr)->flags & IAFlag1) {
                         CError_FATAL(2076);
                     } else {
                         branch_label(makepclabel());
@@ -1911,19 +1893,69 @@ void CodeGen_UpdateBackEndOptions(void) {
 }
 
 SInt32 CodeGen_objc_method_self_offset(ObjCMethod *meth) {
-    // TODO objc
+    SInt32 size;
+
+    if (!meth->return_type) {
+        size = 4;
+    } else if (
+        IS_TYPE_ARRAY(meth->return_type) ||
+        IS_TYPE_NONVECTOR_STRUCT(meth->return_type) ||
+        IS_TYPE_CLASS(meth->return_type) ||
+        IS_TYPE_12BYTES_MEMBERPOINTER(meth->return_type)
+        )
+    {
+        size = 8;
+    } else {
+        size = meth->return_type->size;
+    }
+
+    if (size == 0)
+        size = 1;
+
+    return (size + 3) & ~3;
 }
 
 SInt32 CodeGen_objc_method_sel_offset(ObjCMethod *meth) {
-    // TODO objc
+    return (CodeGen_objc_method_self_offset(meth) + 7) & ~3;
 }
 
 SInt32 CodeGen_objc_method_arg_offset(ObjCMethod *meth, ObjCMethodArg *arg) {
-    // TODO objc
+    SInt32 pos;
+    ObjCMethodArg *scan;
+
+    pos = CodeGen_objc_method_sel_offset(meth) + 4;
+    for (scan = meth->selector_args; scan; scan = scan->next) {
+        if (scan == arg)
+            return pos;
+
+        if (scan->type == NULL)
+            pos += 4;
+        else
+            pos += scan->type->size;
+
+        pos = (pos + 3) & ~3;
+    }
+
+    return 0;
 }
 
 SInt32 CodeGen_objc_method_args_size(ObjCMethod *meth) {
-    // TODO objc
+    SInt32 size;
+    ObjCMethodArg *scan;
+
+    size = CodeGen_objc_method_self_offset(meth);
+    for (scan = meth->selector_args; scan; scan = scan->next) {
+        if (scan->next == NULL && scan->type == NULL)
+            return size;
+
+        size = (size + 3) & ~3;
+        if (scan->type == NULL)
+            size += 4;
+        else
+            size += scan->type->size;
+    }
+
+    return size;
 }
 
 ENode *CodeGen_HandleIntrinsicCall(Object *func, ENodeList *arg_exprs) {
@@ -1959,11 +1991,16 @@ ENode *CodeGen_HandleTypeCast(ENode *expr, Type *type, UInt32 qual) {
     return NULL;
 }
 
-short CodeGen_AssignCheck(ENode *expr, Type *type, Boolean flag1, Boolean flag2) {
+short CodeGen_AssignCheck(const ENode *expr, const Type *type, Boolean flag1, Boolean flag2) {
     short result;
-    Type *exprtype = expr->rtype;
-
-    if (copts.altivec_model && IS_TYPE_VECTOR(type) && IS_TYPE_VECTOR(exprtype) && TYPE_STRUCT(type)->stype == TYPE_STRUCT(exprtype)->stype)
+    const Type *exprtype = expr->rtype;
+
+    if (
+        copts.altivec_model &&
+        IS_TYPE_VECTOR(type) &&
+        IS_TYPE_VECTOR(exprtype) &&
+        TYPE_STRUCT(type)->stype == TYPE_STRUCT(exprtype)->stype
+        )
         result = CheckResult3;
     else
         result = CheckResult0;
diff --git a/compiler_and_linker/unsorted/CodeGenOptPPC.c b/compiler_and_linker/unsorted/CodeGenOptPPC.c
index 5723395..4964435 100644
--- a/compiler_and_linker/unsorted/CodeGenOptPPC.c
+++ b/compiler_and_linker/unsorted/CodeGenOptPPC.c
@@ -1,17 +1,120 @@
 #include "compiler/CodeGenOptPPC.h"
 #include "compiler/InstrSelection.h"
+#include "compiler/CCompiler.h"
+#include "pref_structs.h"
+#include "compiler/CParser.h"
+
+static short pref_versions;
 
 void CodeGen_InitCompiler(void) {
     init_cgdispatch();
 }
 
 void CodeGen_TermCompiler(void) {
-
+    // empty!
 }
 
 void CodeGen_InitBackEndOptions(void) {
-    // TODO
+    Handle handle;
+    PBackEnd pb;
+    PMachOLinker pmol;
+
+    CWSecretGetNamedPreferences(cparams.context, "PPC CodeGen Mach-O", &handle);
+    pb = *((PBackEnd *) *handle);
+    pref_versions = pb.version;
+
+    CWSecretGetNamedPreferences(cparams.context, "PPC Mach-O Linker", &handle);
+    pmol = *((PMachOLinker *) *handle);
+
+    copts.code_alignment = 16;
+    copts.misaligned_mem_access = 1;
+    copts.switch_tables = 1;
+    copts.prepare_compress = 0;
+    copts.some_alignment = 4;
+    copts.altivec_model = 0;
+    copts.altivec_vrsave = 1;
+    copts.codegen_pic = pb.pic;
+    copts.codegen_dynamic = pb.dynamic;
+    if (!copts.codegen_dynamic)
+        copts.codegen_pic = 0;
+    copts.no_common = !pb.common;
+    copts.no_implicit_templates = 0;
+    copts.absolutepath = pmol.symfullpath;
+    copts.x06 = pmol.exports;
+    copts.schedule_mode = 2;
+    copts.altivec_model = pb.altivec;
+    copts.readonly_strings = pb.readonlystrings;
+    if (pb.schedule)
+        copts.schedule_mode = 2;
+    else
+        copts.schedule_mode = 0;
+
+    switch (pb.processor) {
+        case 1:
+            copts.cpu = CPU_PPC601;
+            copts.schedule_cpu = 1;
+            break;
+        case 2:
+            copts.cpu = CPU_PPC603;
+            copts.schedule_cpu = 2;
+            break;
+        case 3:
+            copts.cpu = CPU_PPC603e;
+            copts.schedule_cpu = 5;
+            break;
+        case 4:
+            copts.cpu = CPU_PPC604;
+            copts.schedule_cpu = 3;
+            break;
+        case 5:
+            copts.cpu = CPU_PPC604e;
+            copts.schedule_cpu = 6;
+            break;
+        case 6:
+            copts.cpu = CPU_PPC750;
+            copts.schedule_cpu = 4;
+            break;
+        case 7:
+            copts.cpu = CPU_PPC7400;
+            copts.schedule_cpu = 7;
+            break;
+        case 8:
+            copts.cpu = CPU_PPC7450;
+            copts.schedule_cpu = 10;
+            break;
+        default:
+            copts.cpu = CPU_Generic;
+            copts.schedule_cpu = 8;
+            break;
+    }
+
+    copts.peephole = pb.peephole;
+    copts.align_mode = pb.structalignment;
+    copts.profile = pb.profiler;
+    copts.fp_contract = pb.fpcontract;
+    copts.traceback = pb.tracebacktables > 0;
+    copts.x1D = pb.tracebacktables == 2;
+    copts.x1E = 0;
+    if (pb.processorspecific && copts.cpu >= CPU_PPC603)
+        copts.gen_fsel = 10;
+    else
+        copts.gen_fsel = 0;
+    if (pb.vrsave)
+        copts.altivec_vrsave = 1;
+    else
+        copts.altivec_vrsave = 0;
+    copts.ppc_unroll_speculative = 1;
+    copts.ppc_unroll_instructions_limit = 70;
+    copts.ppc_unroll_factor_limit = 10;
+    copts.ppc_opt_bclr_bcctr = 1;
+    copts.use_lmw_stmw = 1;
+    if (copts.optimizationlevel > 2)
+        copts.optimizewithasm = 1;
+    else
+        copts.optimizewithasm = 0;
+    copts.opt_strength_reduction_strict = 1;
 }
 
 void Test_Version_Numbers(void) {
+    // empty!
 }
diff --git a/compiler_and_linker/unsorted/Exceptions.c b/compiler_and_linker/unsorted/Exceptions.c
index 80d0cc4..cd25577 100644
--- a/compiler_and_linker/unsorted/Exceptions.c
+++ b/compiler_and_linker/unsorted/Exceptions.c
@@ -553,7 +553,7 @@ static UInt32 findPC_long(PCode *instr) {
     return pc;
 }
 
-static void initializeexceptiontables(void) {
+void initializeexceptiontables(void) {
     int i;
 
     for (i = 0; i < EAT_NACTIONS; i++)
@@ -737,7 +737,7 @@ void recordexceptionactions(PCode *instr, ExceptionAction *actions) {
     }
 }
 
-void deleteexceptionaction(PCAction *pca) {
+static void deleteexceptionaction(PCAction *pca) {
     if (pca->prev)
         pca->prev->next = pca->next;
     else
diff --git a/compiler_and_linker/unsorted/FuncLevelAsmPPC.c b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
index a1ea8cc..e7fe347 100644
--- a/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
+++ b/compiler_and_linker/unsorted/FuncLevelAsmPPC.c
@@ -119,7 +119,7 @@ static void FuncAsm_PreScanDirectives(void) {
     cprep_eoltokens = 1;
 
     if (setjmp(InlineAsm_assemblererror) == 0) {
-        while (tk == TK_IDENTIFIER && (directive = InlineAsm_IsDirective(1))) {
+        while (tk == TK_IDENTIFIER && (directive = InlineAsm_IsDirective(AssemblerType_0))) {
             InlineAsm_ProcessDirective(directive);
 
             if (tk == ';' || tk == TK_NEG7) {
diff --git a/compiler_and_linker/unsorted/GCCInlineAsm.c b/compiler_and_linker/unsorted/GCCInlineAsm.c
index 9bceb19..d0ae953 100644
--- a/compiler_and_linker/unsorted/GCCInlineAsm.c
+++ b/compiler_and_linker/unsorted/GCCInlineAsm.c
@@ -1,33 +1,230 @@
 #include "compiler/GCCInlineAsm.h"
+#include "compiler/CError.h"
+#include "compiler/CExpr.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInt64.h"
+#include "compiler/CParser.h"
+#include "compiler/CPrep.h"
+#include "compiler/CPrepTokenizer.h"
+#include "compiler/InlineAsm.h"
+#include "compiler/objects.h"
 
 Statement *first_ST_ASM;
+IALookupResult gcc_name_list[20];
+int gcc_name_list_index;
 
-void InlineAsm_SkipComment() {
+void InlineAsm_SkipComment(void) {
+    while (1) {
+        if (tk != '/')
+            break;
+        if (lookahead() != '*')
+            break;
+
+        tk = lex();
+        while (!((tk = lex()) == '*' && (tk = lex()) == '/')) {
+            // nothing
+        }
+        tk = lex();
+    }
 }
 
-static void gcc_parse_attribute() {
+static char gcc_parse_attribute(void) {
+    char ch;
+
+    while (tk == TK_NEG7)
+        tk = lex();
+
+    if (tk != '"')
+        CError_Error(CErrorStr105);
+
+    while ((tk = lex()) != TK_IDENTIFIER) {
+        // nothing
+    }
+
+    ch = tkidentifier->name[0];
+
+    if ((tk = lex()) != '"')
+        CError_Error(CErrorStr105);
+    tk = lex();
+
+    return ch;
 }
 
-static void gcc_parse_name() {
+static void gcc_parse_name(Boolean flag, char attribute) {
+    IALookupResult *nameentry;
+    ENode *expr;
+    Object *tempobj;
+    ENode *tempexpr;
+    Statement *stmt;
+
+    while (tk == TK_NEG7)
+        tk = lex();
+
+    if (tk != '(')
+        CError_Error(CErrorStr114);
+
+    tk = lex();
+
+    if (flag) {
+        if (tk != TK_IDENTIFIER)
+            CError_Error(CErrorStr105);
+
+        InlineAsm_LookupSymbol(tkidentifier, &gcc_name_list[++gcc_name_list_index]);
+        if (gcc_name_list[gcc_name_list_index].object && gcc_name_list[gcc_name_list_index].object->u.var.info)
+            gcc_name_list[gcc_name_list_index].object->u.var.info->used = 1;
+
+        tk = lex();
+    } else {
+        in_assembler = 0;
+        cprep_nostring = 0;
+        nameentry = &gcc_name_list[++gcc_name_list_index];
+
+        expr = expression();
+        if (attribute == 'i' || attribute == 'I') {
+            if (!ENODE_IS(expr, EINTCONST))
+                CError_Error(CErrorStr144);
+            nameentry->value = CInt64_GetULong(&expr->data.intval);
+            nameentry->has_value = 1;
+        } else {
+            tempobj = create_temp_object(expr->rtype);
+            tempexpr = create_objectnode(tempobj);
+            if (tempobj->u.var.info)
+                tempobj->u.var.info->used = 1;
+            expr = makediadicnode(tempexpr, expr, EASS);
+
+            stmt = CFunc_InsertBeforeStatement(ST_EXPRESSION, first_ST_ASM);
+            first_ST_ASM = stmt->next;
+            if (!first_ST_ASM->next)
+                curstmt = first_ST_ASM;
+            stmt->expr = expr;
+
+            nameentry->name = tempobj->name;
+            nameentry->object = tempobj;
+            nameentry->label = NULL;
+            nameentry->type = NULL;
+            nameentry->has_value = 0;
+        }
+    }
+
+    cprep_nostring = 1;
+    in_assembler = 1;
+
+    if (tk != ')')
+        CError_Error(CErrorStr115);
+    tk = lex();
 }
 
-static void gcc_parse_expression() {
+static void gcc_parse_expression(Boolean flag) {
+    while (1) {
+        gcc_parse_name(flag, gcc_parse_attribute());
+        if (tk != ',')
+            break;
+        tk = lex();
+    }
 }
 
-static void gcc_parse_input() {
+static void gcc_parse_input(void) {
+    if (tk == ':') {
+        if ((tk = lex()) == ':' || tk == ')' || tk == '}')
+            return;
+        gcc_parse_expression(0);
+    }
 }
 
-static void gcc_parse_output() {
+static void gcc_parse_output(void) {
+    if (tk == ':') {
+        if ((tk = lex()) == ':' || tk == ')' || tk == '}')
+            return;
+        gcc_parse_expression(1);
+    }
 }
 
-static void gcc_parse_killed() {
+static void gcc_parse_killed(void) {
+    if (tk == ':') {
+        while (1) {
+            if ((tk = lex()) != '"')
+                return;
+
+            tk = lex();
+            while (1) {
+                if (tk == '"') {
+                    if (lookahead() == ',') {
+                        tk = lex();
+                        break;
+                    }
+                    tk = lex();
+                    return;
+                }
+                tk = lex();
+            }
+        }
+    }
 }
 
-static void gcc_replace_arg_st_asm() {
+static void gcc_replace_arg_st_asm(Statement *stmt) {
+    InlineAsm *ia;
+    int i;
+    IAOperand *op;
+    short effect;
+    short rclass;
+    SInt32 num;
+
+    if ((ia = (InlineAsm *) stmt->expr)) {
+        for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
+            switch (op->type) {
+                case IAOpnd_Imm:
+                case IAOpnd_Reg:
+                case IAOpnd_3:
+                case IAOpnd_4:
+                case IAOpnd_Lab:
+                    break;
+
+                case IAOpnd_6:
+                    if (op->u.unk6.unk4 == 2) {
+                        effect = op->u.unk6.effect;
+                        rclass = op->u.unk6.rclass;
+                        num = op->u.unk6.num;
+                        op->type = IAOpnd_Reg;
+                        op->u.reg.effect = effect;
+                        op->u.reg.rclass = rclass;
+                        op->u.reg.object = NULL;
+                        if (num <= gcc_name_list_index)
+                            op->u.reg.object = gcc_name_list[num].object;
+                        else
+                            CError_Error(CErrorStr144);
+                        op->u.reg.num = 0;
+                    } else {
+                        CError_FATAL(365);
+                    }
+                    break;
+
+                case IAOpnd_7:
+                    op->type = IAOpnd_Imm;
+                    op->u.imm.value = gcc_name_list[op->u.unk7.value].value;
+                    break;
+            }
+        }
+    }
 }
 
-static void gcc_replace_arg() {
+static void gcc_replace_arg(void) {
+    Statement *stmt;
+
+    for (stmt = first_ST_ASM; stmt; stmt = stmt->next) {
+        if (stmt->type == ST_ASM)
+            gcc_replace_arg_st_asm(stmt);
+    }
 }
 
 void InlineAsm_gcc_parse(void) {
+    gcc_name_list_index = -1;
+    cprep_eoltokens = 0;
+
+    if (tk == TK_NEG7)
+        tk = lex();
+
+    gcc_parse_output();
+    gcc_parse_input();
+    gcc_parse_killed();
+    gcc_replace_arg();
 }
diff --git a/compiler_and_linker/unsorted/InlineAsm.c b/compiler_and_linker/unsorted/InlineAsm.c
index 628c678..e800327 100644
--- a/compiler_and_linker/unsorted/InlineAsm.c
+++ b/compiler_and_linker/unsorted/InlineAsm.c
@@ -591,7 +591,7 @@ Object *InlineAsm_GetObjectOffset(InlineAsm *ia, SInt32 index, SInt32 *offset) {
     for (i = 0, counter = 0, op = ia->args; i < ia->argcount; i++, op++) {
         if (op->type == IAOpnd_3) {
             if (counter++ == index) {
-                *offset = ((SInt32) &op->u.obj.obj) - ((SInt32) ia);
+                *offset = ((intptr_t) &op->u.obj.obj) - ((intptr_t) ia);
                 return op->u.obj.obj;
             }
         }
diff --git a/compiler_and_linker/unsorted/InlineAsmPPC.c b/compiler_and_linker/unsorted/InlineAsmPPC.c
index 19c8fdc..e3a5f98 100644
--- a/compiler_and_linker/unsorted/InlineAsmPPC.c
+++ b/compiler_and_linker/unsorted/InlineAsmPPC.c
@@ -1,32 +1,29 @@
 #include "compiler/InlineAsmPPC.h"
 #include "compiler/CError.h"
+#include "compiler/CExpr.h"
 #include "compiler/CInt64.h"
 #include "compiler/CFunc.h"
 #include "compiler/CMachine.h"
 #include "compiler/CParser.h"
 #include "compiler/CPrep.h"
 #include "compiler/CPrepTokenizer.h"
-#include "compiler/TOC.h"
+#include "compiler/Alias.h"
+#include "compiler/CodeGen.h"
+#include "compiler/CodeGenOptPPC.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/Exceptions.h"
 #include "compiler/FuncLevelAsmPPC.h"
 #include "compiler/InlineAsm.h"
 #include "compiler/InlineAsmMnemonicsPPC.h"
 #include "compiler/InlineAsmRegisters.h"
 #include "compiler/InlineAsmRegistersPPC.h"
-#include "compiler/CodeGen.h"
-#include "compiler/CodeGenOptPPC.h"
-#include "compiler/PPCError.h"
-#include "compiler/RegisterInfo.h"
-#include "compiler/objects.h"
-#include "compiler/CExpr.h"
 #include "compiler/PCode.h"
 #include "compiler/PCodeUtilities.h"
+#include "compiler/PPCError.h"
+#include "compiler/RegisterInfo.h"
 #include "compiler/StackFrame.h"
-#include "compiler/CompilerTools.h"
-#include "compiler/Alias.h"
-
-// TODO: move me
-extern int countexceptionactionregisters(ExceptionAction *);
-extern void noteexceptionactionregisters(ExceptionAction *, PCodeArg *);
+#include "compiler/TOC.h"
+#include "compiler/objects.h"
 
 char asm_alloc_flags[10];
 Section sm_section;
@@ -35,17 +32,12 @@ SInt32 fralloc_parameter_area_size;
 Boolean user_responsible_for_frame;
 Boolean supports_hardware_fpu;
 UInt32 assembledinstructions;
-UInt8 assembler_type;
+AssemblerType assembler_type;
 char volatileasm;
 Boolean InlineAsm_gccmode;
 Boolean InlineAsm_labelref;
 CLabel *pic_base_label;
 
-enum {
-    NO_REG = 0,
-    INVALID_PIC_REG = -2
-};
-
 // forward decls
 static SInt32 InlineAsm_ConstantExpressionPPC(SInt32 value);
 static Object *isvariableoperand(void);
@@ -71,8 +63,9 @@ static void IllegalObjectOperator(HashNameNode *name1, HashNameNode *name2, shor
         case TK_SHR: opstr = ">>"; break;
         case '<': opstr = "<"; break;
         case '>': opstr = ">"; break;
-        case TK_LESS_EQUAL: opstr = "<="; break;
-        case TK_GREATER_EQUAL: opstr = ">="; break;
+        // bug? these two seem swapped
+        case TK_LESS_EQUAL: opstr = ">="; break;
+        case TK_GREATER_EQUAL: opstr = "<="; break;
         case TK_LOGICAL_EQ: opstr = "=="; break;
         case TK_LOGICAL_NE: opstr = "!="; break;
         case '&': opstr = "&"; break;
@@ -1478,7 +1471,7 @@ static int mnemonic_has_overflow(char *buf) {
     return result;
 }
 
-static int mnemonic_has_absolute(char *buf) {
+static int mnemonic_has_absolute(const char *buf) {
     int result = 0;
     char last = buf[strlen(buf) - 1];
 
@@ -1488,7 +1481,7 @@ static int mnemonic_has_absolute(char *buf) {
     return result;
 }
 
-static int mnemonic_has_linkregister(char *buf) {
+static int mnemonic_has_linkregister(const char *buf) {
     int result = 0;
     char last = buf[strlen(buf) - 1];
 
@@ -1552,7 +1545,7 @@ void InlineAsm_InitializePPC(void) {
         cpu |= 0x40000000;
 }
 
-void InlineAsm_Initialize(UInt8 assemblertype) {
+void InlineAsm_Initialize(AssemblerType assemblertype) {
     assembler_type = assemblertype;
 
     if (assembler_type == 0) {
@@ -1608,7 +1601,7 @@ static InlineAsm *InlineAsm_CreateFrFree(void) {
     return ia;
 }
 
-SInt32 InlineAsm_IsDirective(UInt8 assemblertype) {
+SInt32 InlineAsm_IsDirective(AssemblerType assemblertype) {
     char *name;
     SInt32 directive = IADirective_Null;
 
@@ -1619,7 +1612,7 @@ SInt32 InlineAsm_IsDirective(UInt8 assemblertype) {
         name = tkidentifier->name;
         if (!strcmp(name, "machine")) {
             directive = IADirective_Machine;
-        } else if (assemblertype == 1) {
+        } else if (assemblertype == AssemblerType_1) {
             if (!strcmp(name, "entry")) {
                 directive = IADirective_Entry;
             } else if (!strcmp(name, "fralloc")) {
@@ -1815,6 +1808,7 @@ void InlineAsm_ScanAssemblyInstruction(void) {
     Boolean flag1;
     Boolean flag2;
     SInt32 directive;
+    OpcodeInfo *info;
     char buf[20];
 
     flag1 = 0;
@@ -1837,9 +1831,10 @@ void InlineAsm_ScanAssemblyInstruction(void) {
     if (!mnemonic)
         CError_Error(CErrorStr261);
 
-    flag3 = (FLAG_SET_F(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag4000000) && (mnemonic->x10 & 0x400);
-    flag4 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag20000000) && (mnemonic->x10 & 2);
-    flag5 = (FLAG_SET_T(opcodeinfo[mnemonic->x4].flags) & fPCodeFlag2000000) && (mnemonic->x10 & 1);
+    info = &opcodeinfo[mnemonic->x4];
+    flag3 = (FLAG_SET_F(info->flags) & fPCodeFlag4000000) && (mnemonic->x10 & 0x400);
+    flag4 = (FLAG_SET_T(info->flags) & fPCodeFlag20000000) && (mnemonic->x10 & 2);
+    flag5 = (FLAG_SET_T(info->flags) & fPCodeFlag2000000) && (mnemonic->x10 & 1);
 
     if ((cpu == CPUMask_Generic) && (cpu & CPUFLAG_LOW_MASK) != ((cpu & mnemonic->cpu) & CPUFLAG_LOW_MASK)) {
         CError_Error(CErrorStr152);
@@ -1901,8 +1896,7 @@ void InlineAsm_ScanAssemblyInstruction(void) {
     ++assembledinstructions;
 }
 
-static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8 assemblertype) {
-    OpcodeInfo *info;
+static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, AssemblerType assemblertype) {
     PCode *pc;
     int index;
     int extra_args;
@@ -1911,6 +1905,7 @@ static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8
     SInt32 buffersize;
     IAOperand *src;
     PCodeArg *dest;
+    OpcodeInfo *info;
 
     info = &opcodeinfo[ia->opcode];
     index = 0;
@@ -2106,7 +2101,7 @@ static PCode *InlineAsm_TranslateIRtoPCodePPC(InlineAsm *ia, int argcount, UInt8
             dest->kind = PCOp_REGISTER;
             dest->arg = RegClass_GPR;
             dest->data.reg.reg = i;
-            dest->data.reg.effect = (short) ((ia->opcode == PC_LMW) ? EffectWrite : EffectRead);
+            dest->data.reg.effect = ((ia->opcode == PC_LMW) ? EffectWrite : EffectRead);
         }
     }
 
@@ -2485,8 +2480,8 @@ void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects) {
                 CError_FATAL(4087);
         }
 
-        CError_ASSERT(4090, effects->numoperands <= 16);
-        CError_ASSERT(4093, effects->numlabels <= 16);
+        CError_ASSERT(4090, (UInt32) effects->numoperands <= IAMaxOperands);
+        CError_ASSERT(4093, (UInt32) effects->numlabels <= IAMaxLabels);
     }
 
     for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
@@ -2526,7 +2521,7 @@ void CodeGen_GetAsmEffects(Statement *stmt, IAEffects *effects) {
                 break;
         }
 
-        CError_ASSERT(4151, effects->numoperands <= 16);
+        CError_ASSERT(4151, (UInt32) effects->numoperands <= IAMaxOperands);
     }
 
     if ((info->flags & (fPCodeFlag1 | fPCodeFlag8)) && (SInt32)effects->numlabels == 0)
diff --git a/compiler_and_linker/unsorted/InstrSelection.c b/compiler_and_linker/unsorted/InstrSelection.c
index ac60baf..1916711 100644
--- a/compiler_and_linker/unsorted/InstrSelection.c
+++ b/compiler_and_linker/unsorted/InstrSelection.c
@@ -4,20 +4,20 @@
 #include "compiler/CMachine.h"
 #include "compiler/CParser.h"
 #include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/FunctionCalls.h"
+#include "compiler/Intrinsics.h"
 #include "compiler/Operands.h"
 #include "compiler/PCode.h"
 #include "compiler/PCodeInfo.h"
 #include "compiler/PCodeUtilities.h"
 #include "compiler/RegisterInfo.h"
+#include "compiler/StructMoves.h"
 #include "compiler/TOC.h"
-#include "compiler/CompilerTools.h"
 #include "compiler/enode.h"
 #include "compiler/objects.h"
 #include "compiler/types.h"
 
-// TODO: move me
-extern void move_block(Operand *, Operand *, SInt32, SInt32);
-
 PrecomputedOperand *precomputedoperands;
 void (*cgdispatch[MAXEXPR + 1])(ENode *, short, short, Operand *);
 
@@ -103,8 +103,7 @@ void gen_DEFINE(ENode *expr, short outputReg, short outputRegHi, Operand *output
 
 void gen_REUSE(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
     ENode *inner = expr->data.monadic;
-#line 250
-    CError_ASSERT(ENODE_IS(inner, EDEFINE));
+    CError_ASSERT(250, ENODE_IS(inner, EDEFINE));
     gen_DEFINE(inner, outputReg, outputRegHi, output);
 }
 
@@ -250,8 +249,7 @@ void gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *outp
                 output->optype = OpndType_CRField;
                 break;
             default:
-#line 456
-                CError_FATAL();
+                CError_FATAL(456);
         }
         output->reg = vi->reg;
         output->object = NULL;
@@ -386,8 +384,7 @@ void gen_FORCELOAD(ENode *expr, short outputReg, short outputRegHi, Operand *out
         else
             ENSURE_GPR(output, inner->rtype, outputReg);
     } else if (!IS_TYPE_VOID(inner->rtype)) {
-#line 681
-        CError_FATAL();
+        CError_FATAL(681);
     }
 }
 
@@ -1114,8 +1111,7 @@ void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
         if (ENODE_IS(left, EINDIRECT)) {
             left = left->data.monadic;
         } else {
-#line 1759
-            CError_FATAL();
+            CError_FATAL(1759);
         }
         right = expr->data.cond.expr2;
     } else {
@@ -1149,8 +1145,7 @@ void gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
                 output->optype = OpndType_VR;
                 break;
             default:
-#line 1810
-                CError_FATAL();
+                CError_FATAL(1810);
         }
         if (opright.reg != vi->reg) {
             PCodeArg a, b;
@@ -1382,14 +1377,12 @@ void gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *output
     } else if (srctype->size == dsttype->size) {
         GEN_NODE_TO_REG(inner, outputReg, 0, output);
     } else {
-#line 2224
-        CError_FATAL();
+        CError_FATAL(2224);
     }
 }
 
 void gen_BITFIELD(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2238
-    CError_FATAL();
+    CError_FATAL(2238);
 }
 
 void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -1403,13 +1396,11 @@ void gen_INTCONST(ENode *expr, short outputReg, short outputRegHi, Operand *outp
 }
 
 void gen_FLOATCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2294
-    CError_FATAL();
+    CError_FATAL(2294);
 }
 
 void gen_STRINGCONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 2308
-    CError_FATAL();
+    CError_FATAL(2308);
 }
 
 static Boolean COND_is_ABS_MatchNodes(ENode *cond, ENode *expr1, ENode *expr2) {
@@ -1619,6 +1610,8 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
         Boolean flag;
         Operand op;
         int fneg_reg;
+        int fneg_reg2;
+        int fneg_reg3;
         int fsel_reg;
         int final_reg;
 
@@ -1648,8 +1641,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
                 right = tmp;
                 break;
             default:
-#line 2780
-                CError_FATAL();
+                CError_FATAL(2780);
         }
 
         if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) {
@@ -1680,12 +1672,12 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
                     GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0);
                     GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0);
 
-                    fneg_reg = ALLOC_FPR();
-                    emitpcode(PC_FNEG, fneg_reg, op.reg);
+                    fneg_reg2 = ALLOC_FPR();
+                    emitpcode(PC_FNEG, fneg_reg2, op.reg);
                     fsel_reg = ALLOC_FPR();
                     emitpcode(PC_FSEL, fsel_reg, op.reg, op1.reg, op2.reg);
                     final_reg = outputReg ? outputReg : ALLOC_FPR();
-                    emitpcode(PC_FSEL, final_reg, fneg_reg, fsel_reg, op2.reg);
+                    emitpcode(PC_FSEL, final_reg, fneg_reg2, fsel_reg, op2.reg);
                 }
                 break;
             case ELESS:
@@ -1695,18 +1687,17 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
                 GEN_NODE_TO_FPR(expr1, &op1, expr1->rtype, 0);
                 GEN_NODE_TO_FPR(expr2, &op2, expr2->rtype, 0);
 
-                fneg_reg = op.reg;
+                fneg_reg3 = op.reg;
                 if (flag) {
-                    fneg_reg = ALLOC_FPR();
-                    emitpcode(PC_FNEG, fneg_reg, op.reg);
+                    fneg_reg3 = ALLOC_FPR();
+                    emitpcode(PC_FNEG, fneg_reg3, op.reg);
                 }
 
                 final_reg = outputReg ? outputReg : ALLOC_FPR();
-                emitpcode(PC_FSEL, final_reg, fneg_reg, op1.reg, op2.reg);
+                emitpcode(PC_FSEL, final_reg, fneg_reg3, op1.reg, op2.reg);
                 break;
             default:
-#line 2862
-                CError_FATAL();
+                CError_FATAL(2862);
         }
 
         output->optype = OpndType_FPR;
@@ -1814,8 +1805,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
                         ENSURE_GPR(&op1, expr1->rtype, 0);
                         emitpcode(PC_AND, reg1, op1.reg, isel_op1.reg);
                     } else {
-#line 3119
-                        CError_FATAL();
+                        CError_FATAL(3119);
                     }
 
                     output->optype = OpndType_GPR;
@@ -1851,8 +1841,7 @@ void gen_COND(ENode *expr, short outputReg, short outputRegHi, Operand *output)
                     return;
 
                 default:
-#line 3168
-                    CError_FATAL();
+                    CError_FATAL(3168);
             }
         }
 
@@ -2157,9 +2146,8 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
         flag = 0;
         memclrw(&op, sizeof(Operand));
 
-#line 3704
-        CError_ASSERT(ENODE_IS(expr1, EINDIRECT));
-        CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF));
+        CError_ASSERT(3704, ENODE_IS(expr1, EINDIRECT));
+        CError_ASSERT(3705, ENODE_IS(expr1->data.monadic, EOBJREF));
 
         tmpreg = OBJECT_REG(expr1->data.monadic->data.objref);
         final_reg = outputReg ? tmpreg : ALLOC_FPR();
@@ -2187,8 +2175,7 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
                 flag2 = 0;
                 break;
             default:
-#line 3744
-                CError_FATAL();
+                CError_FATAL(3744);
         }
 
         if (ENODE_IS(left, EFLOATCONST) && CMach_FloatIsZero(left->data.floatval)) {
@@ -2251,8 +2238,7 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
                 emitpcode(PC_FSEL, final_reg, fneg_reg, op2.reg, op1.reg);
                 break;
             default:
-#line 2862
-                CError_FATAL();
+                CError_FATAL(2862);
         }
 
         if (op3.optype != OpndType_FPR)
@@ -2270,10 +2256,8 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
         ENode *abs_expr;
 
         memclrw(&isel_op, sizeof(Operand));
-#line 3966
-        CError_ASSERT(ENODE_IS(expr1, EINDIRECT));
-#line 3968
-        CError_ASSERT(ENODE_IS(expr1->data.monadic, EOBJREF));
+        CError_ASSERT(3966, ENODE_IS(expr1, EINDIRECT));
+        CError_ASSERT(3968, ENODE_IS(expr1->data.monadic, EOBJREF));
 
         if (CONDASS_is_ABS(cond, expr1, expr2)) {
             if (ENODE_IS(cond->data.diadic.left, EASS))
@@ -2282,14 +2266,12 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
                 GEN_NODE(cond->data.diadic.right, &isel_op);
 
             outputReg = OBJECT_REG(expr1->data.monadic->data.objref);
-#line 3979
-            CError_ASSERT(outputReg);
+            CError_ASSERT(3979, outputReg);
 
             GEN_NODE(expr1, &op1);
             op3 = op1;
 
-#line 3986
-            CError_ASSERT(op3.optype == OpndType_GPR && op3.reg == outputReg);
+            CError_ASSERT(3986, op3.optype == OpndType_GPR && op3.reg == outputReg);
 
             ENSURE_GPR(&op1, expr1->rtype, 0);
             if (expr1->rtype->size < 4)
@@ -2317,6 +2299,10 @@ void gen_CONDASS(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
 }
 
 void gen_FUNCCALL(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
+    if (is_intrinsic_function_call(expr))
+        call_intrinsic_function(expr, outputReg, output);
+    else
+        call_function(expr, output);
 }
 
 void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -2324,8 +2310,7 @@ void gen_OBJREF(ENode *expr, short outputReg, short outputRegHi, Operand *output
 }
 
 void gen_UNEXPECTED(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
-#line 4160
-    CError_FATAL();
+    CError_FATAL(4160);
 }
 
 static int small(ENode *expr) {
@@ -2658,8 +2643,7 @@ void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
 
             tmpreg1 = ALLOC_GPR();
             tmpreg2 = ALLOC_GPR();
-#line 4853
-            CError_ASSERT(output->optype == OpndType_GPR);
+            CError_ASSERT(4853, output->optype == OpndType_GPR);
 
             emitpcode(PC_CNTLZW, tmpreg2, output->reg);
             emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31);
@@ -2685,8 +2669,7 @@ void gen_LOGICAL(ENode *expr, short outputReg, short outputRegHi, Operand *outpu
 
             tmpreg1 = ALLOC_GPR();
             tmpreg2 = ALLOC_GPR();
-#line 4883
-            CError_ASSERT(output->optype == OpndType_GPR);
+            CError_ASSERT(4883, output->optype == OpndType_GPR);
 
             emitpcode(PC_CNTLZW, tmpreg2, output->reg);
             emitpcode(PC_RLWINM, tmpreg1, tmpreg2, 27, 5, 31);
@@ -2810,8 +2793,7 @@ void logical_expression(ENode *cond, PCodeLabel *if_true, PCodeLabel *if_false,
                 branch_conditional(op.reg, op.regOffset, 1, if_true);
             break;
         default:
-#line 5160
-            CError_FATAL();
+            CError_FATAL(5160);
     }
 }
 
@@ -2829,8 +2811,7 @@ static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *ou
         case ENOTEQU:
             if (invert) {
                 ENodeType nt = invert_relop(cond->type);
-#line 5190
-                CError_ASSERT(nt != cond->type);
+                CError_ASSERT(5190, nt != cond->type);
                 cond->type = nt;
             }
 
@@ -2841,8 +2822,7 @@ static void logical_expression_nobranch(ENode *cond, Boolean invert, Operand *ou
 
             break;
         default:
-#line 5206
-            CError_FATAL();
+            CError_FATAL(5206);
     }
 }
 
@@ -2999,8 +2979,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
                                         pc->args[1].data.reg.reg,
                                         (r6 + r7 + 1) & 31, 31, 31);
                             } else {
-#line 5434
-                                CError_FATAL();
+                                CError_FATAL(5434);
                             }
                             output->optype = OpndType_GPR;
                             output->reg = reg;
@@ -3061,8 +3040,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
                                         (r6 + r7 + 1) & 31, 31, 31);
                                 emitpcode(PC_XORI, reg, tmpreg, 1);
                             } else {
-#line 5503
-                                CError_FATAL();
+                                CError_FATAL(5503);
                             }
                             output->optype = OpndType_GPR;
                             output->reg = reg;
@@ -3265,8 +3243,7 @@ void gen_condition_gpr(ENode *cond, Operand *output, short outputReg) {
                 }
 
             default:
-#line 5777
-                CError_FATAL();
+                CError_FATAL(5777);
         }
     }
 
@@ -3589,8 +3566,7 @@ void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output
         case 1 + 8:
         case 2 + 8:
         case 4 + 8:
-#line 6933
-            CError_ASSERT(skipleft == 8);
+            CError_ASSERT(6933, skipleft == 8);
             if (!is_uns) {
                 tmpreg2 = ALLOC_GPR();
                 emitpcode(PC_SRAWI, tmpreg2, opright.reg, 31);
@@ -3612,8 +3588,7 @@ void I8_gen_ADD(ENode *expr, short outputReg, short outputRegHi, Operand *output
             emitpcode(PC_ADDE, regHi, opleft.regHi, opright.regHi);
             break;
         default:
-#line 6979
-            CError_FATAL();
+            CError_FATAL(6979);
     }
 
     output->optype = OpndType_GPRPair;
@@ -3745,8 +3720,7 @@ void I8_gen_SUB(ENode *expr, short outputReg, short outputRegHi, Operand *output
             emitpcode(PC_SUBFE, regHi, opright.regHi, opleft.regHi);
             break;
         default:
-#line 7211
-            CError_FATAL();
+            CError_FATAL(7211);
     }
 
     output->optype = OpndType_GPRPair;
@@ -3840,10 +3814,8 @@ int I8_log2n(UInt64 val) {
 }
 
 void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 size, short reg, short regHi) {
-    if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) {
-#line 7703
-        CError_FATAL();
-    }
+    if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg)
+        CError_FATAL(7703);
 
     if (value < 32) {
         emitpcode(PC_RLWINM, reg, opnd.reg, value, 0, 31 - value);
@@ -3860,8 +3832,7 @@ void I8_ShiftLeftImmediate(Operand opnd, SInt32 value, int is_unsigned, SInt32 s
             emitpcode(PC_RLWINM, regHi, opnd.reg, value - 32, 0, 63 - value);
         emitpcode(PC_LI, reg, 0);
     } else {
-#line 7732
-        CError_FATAL();
+        CError_FATAL(7732);
     }
 }
 
@@ -3871,10 +3842,8 @@ void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short r
     short tmpreg3;
     short tmpreg4;
 
-    if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg) {
-#line 7756
-        CError_FATAL();
-    }
+    if (opnd.reg == reg || opnd.regHi == regHi || opnd.reg == regHi || opnd.regHi == reg)
+        CError_FATAL(7756);
 
     if (value < 32) {
         emitpcode(PC_RLWINM, reg, opnd.reg, 32 - value, 0, 31);
@@ -3927,8 +3896,7 @@ void I8_ShiftRightImmediate(Operand opnd, SInt32 value, int is_unsigned, short r
             emitpcode(PC_SRAWI, regHi, opnd.regHi, 31);
         }
     } else {
-#line 7866
-        CError_FATAL();
+        CError_FATAL(7866);
     }
 }
 
@@ -3957,10 +3925,8 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
     skipleft = GetSizeSkip(left);
     skipright = GetSizeSkip(right);
 
-    if (ENODE_IS(right, EINTCONST) && ENODE_IS(left, EINTCONST)) {
-#line 7900
-        CError_FATAL();
-    }
+    if (ENODE_IS(right, EINTCONST) && ENODE_IS(left, EINTCONST))
+        CError_FATAL(7900);
 
     if (ENODE_IS(left, EINTCONST))
         leftval = left->data.intval.lo + (((SInt64) ((skipleft < 8) ? 0 : left->data.intval.hi)) << 32);
@@ -4066,8 +4032,7 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
             case 1 + 8:
             case 2 + 8:
             case 4 + 8:
-#line 8097
-                CError_ASSERT(skipleft == 8);
+                CError_ASSERT(8097, skipleft == 8);
                 if (ENODE_IS(left, EINTCONST) && FITS_IN_SHORT2(left->data.intval.lo) && left->data.intval.hi == 0) {
                     emitpcode(PC_MULLI, reg, opright.reg, LOW_PART(left->data.intval.lo));
                     if (is_uns)
@@ -4143,8 +4108,7 @@ void I8_gen_MUL(ENode *expr, short outputReg, short outputRegHi, Operand *output
                 }
                 break;
             default:
-#line 8218
-                CError_FATAL();
+                CError_FATAL(8218);
         }
     }
 
@@ -4206,12 +4170,10 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
     type = expr->rtype;
     if (ENODE_IS(expr, ECONDASS)) {
         left = expr->data.cond.expr1;
-        if (ENODE_IS(left, EINDIRECT)) {
+        if (ENODE_IS(left, EINDIRECT))
             left = left->data.monadic;
-        } else {
-#line 8328
-            CError_FATAL();
-        }
+        else
+            CError_FATAL(8238);
         right = expr->data.cond.expr2;
     } else {
         left = expr->data.diadic.left;
@@ -4225,8 +4187,7 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
         vi = Registers_GetVarInfo(left->data.objref);
         GEN_NODE_TO_REG(right, vi->reg, vi->regHi, &opright);
         if (vi->rclass != RegClass_GPR) {
-#line 8348
-            CError_FATAL();
+            CError_FATAL(8348);
         } else {
             coerce_to_register_pair(&opright, type, vi->reg, vi->regHi);
             *output = opright;
@@ -4239,8 +4200,7 @@ void I8_gen_ASS(ENode *expr, short outputReg, short outputRegHi, Operand *output
         coerce_to_register_pair(&opright, right->rtype, 0, 0);
 
         if (ENODE_IS(left, EBITFIELD)) {
-#line 8376
-            CError_FATAL();
+            CError_FATAL(8376);
         } else {
             GEN_NODE(left, &opleft);
             indirect(&opleft, left);
@@ -4286,8 +4246,7 @@ void I8_gen_POSTINCDEC(ENode *expr, short outputReg, short outputRegHi, Operand
         return;
     }
 
-#line 8446
-    CError_ASSERT(!ENODE_IS(inner, EBITFIELD));
+    CError_ASSERT(8446, !ENODE_IS(inner, EBITFIELD));
 
     GEN_NODE(inner, &op1);
     indirect(&op1, inner);
@@ -4329,8 +4288,7 @@ void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *o
                 output->optype = OpndType_FPR;
                 break;
             default:
-#line 8511
-                CError_FATAL();
+                CError_FATAL(8511);
         }
 
         output->reg = vi->reg;
@@ -4340,8 +4298,7 @@ void I8_gen_INDIRECT(ENode *expr, short outputReg, short outputRegHi, Operand *o
     }
 
     if (ENODE_IS(inner, EBITFIELD)) {
-#line 8529
-        CError_FATAL();
+        CError_FATAL(8529);
         return;
     }
 
@@ -4430,8 +4387,7 @@ void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr) {
         }
     }
 
-#line 8704
-    CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
+    CError_ASSERT(8704, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
 
     switch (cond->type) {
         case EEQU:
@@ -4525,8 +4481,7 @@ void I8_gen_condition(ENode *cond, Operand *output, int write_to_gpr) {
             }
             break;
         default:
-#line 8814
-            CError_FATAL();
+            CError_FATAL(8814);
     }
 }
 
@@ -4569,8 +4524,7 @@ void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *ou
         opright.optype = OpndType_GPR;
     }
 
-#line 8890
-    CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPR);
+    CError_ASSERT(8890, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPR);
 
     if (opleft.regHi != high_reg)
         emitpcode(PC_MR, high_reg, opleft.regHi);
@@ -4587,8 +4541,7 @@ void I8_gen_SHL_SHR(ENode *expr, short outputReg, short outputRegHi, Operand *ou
     } else if (ENODE_IS(expr, ESHL)) {
         branch_subroutine(rt_shl2i, 0, used_regs);
     } else {
-#line 8909
-        CError_FATAL();
+        CError_FATAL(8909);
     }
 
     emitpcode(PC_MR, output->reg, low_reg);
@@ -4623,8 +4576,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
     if (ENODE_IS(right, EINTCONST))
         constval = (((SInt64) right->data.intval.hi) << 32) + right->data.intval.lo;
     if (ENODE_IS(right, EINTCONST) && ((shift = I8_log2n(constval)) > 0)) {
-#line 8976
-        CError_ASSERT(opleft.optype == OpndType_GPRPair);
+        CError_ASSERT(8976, opleft.optype == OpndType_GPRPair);
         if (ENODE_IS(expr, EDIV)) {
             I8_ShiftRightImmediate(opleft, shift, is_uns, output->reg, output->regHi, 1);
             if (!is_uns) {
@@ -4643,8 +4595,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
                     emitpcode(PC_RLWINM, output->regHi, opleft.regHi, 0, 32 - (shift - 32), 31);
                     emitpcode(PC_MR, output->reg, opleft.reg);
                 } else {
-#line 9018
-                    CError_FATAL();
+                    CError_FATAL(9018);
                 }
             } else {
                 short tmpreg1 = ALLOC_GPR();
@@ -4663,8 +4614,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
     GEN_NODE(right, &opright);
     coerce_to_register_pair(&opright, right->rtype, 0, 0);
 
-#line 9048
-    CError_ASSERT(opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
+    CError_ASSERT(9048, opleft.optype == OpndType_GPRPair && opright.optype == OpndType_GPRPair);
 
     if (opleft.regHi != high_reg)
         emitpcode(PC_MR, high_reg, opleft.regHi);
@@ -4686,8 +4636,7 @@ void I8_gen_DIV_MOD(ENode *expr, short outputReg, short outputRegHi, Operand *ou
         else
             branch_subroutine(rt_mod2i, 0, used_regs);
     } else {
-#line 9074
-        CError_FATAL();
+        CError_FATAL(9074);
     }
 
     emitpcode(PC_MR, output->reg, low_reg);
@@ -4745,8 +4694,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
         }
 
         if (srctype->size < dsttype->size) {
-#line 9171
-            CError_ASSERT(TYPE_IS_8BYTES(dsttype));
+            CError_ASSERT(9171, TYPE_IS_8BYTES(dsttype));
 
             GEN_NODE(inner, output);
             if (srctype->size < 4 &&
@@ -4769,8 +4717,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
 
     if (IS_TYPE_POINTER(srctype)) {
         GEN_NODE_TO_REG(inner, outputReg, 0, output);
-#line 9200
-        CError_ASSERT(TYPE_IS_8BYTES(expr->rtype));
+        CError_ASSERT(9200, TYPE_IS_8BYTES(expr->rtype));
         GEN_NODE_TO_REG(inner, outputReg, 0, output);
 
         regHi = outputRegHi ? outputRegHi : ALLOC_GPR();
@@ -4790,8 +4737,7 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
 
     if (IS_TYPE_FLOAT(srctype)) {
         if (IS_TYPE_FLOAT(dsttype)) {
-#line 9222
-            CError_FATAL();
+            CError_FATAL(9222);
             return;
         }
 
@@ -4816,14 +4762,12 @@ void I8_gen_TYPCON(ENode *expr, short outputReg, short outputRegHi, Operand *out
         if (TYPE_IS_8BYTES(expr->rtype) && dsttype->size == srctype->size) {
             coerce_to_register_pair(output, srctype, outputReg, outputRegHi);
         } else {
-#line 9256
-            CError_FATAL();
+            CError_FATAL(9256);
         }
         return;
     }
 
-#line 9261
-    CError_FATAL();
+    CError_FATAL(9261);
 }
 
 void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand *output) {
@@ -4832,10 +4776,8 @@ void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand
     COVCResult result;
 
     vr = outputReg ? outputReg : ALLOC_VR();
-    if (!canoptimizevectorconst(&expr->data.vector128val, expr->rtype, &result)) {
-#line 9282
-        CError_FATAL();
-    }
+    if (!canoptimizevectorconst(&expr->data.vector128val, expr->rtype, &result))
+        CError_FATAL(9282);
 
     if (result.op1 != -1) {
         emitpcode(result.op1, vr, result.arg);
@@ -4853,6 +4795,5 @@ void gen_VECTOR128CONST(ENode *expr, short outputReg, short outputRegHi, Operand
         return;
     }
 
-#line 9298
-    CError_FATAL();
+    CError_FATAL(9298);
 }
diff --git a/compiler_and_linker/unsorted/IrOptimizer.c b/compiler_and_linker/unsorted/IrOptimizer.c
index 462adf3..ae38df0 100644
--- a/compiler_and_linker/unsorted/IrOptimizer.c
+++ b/compiler_and_linker/unsorted/IrOptimizer.c
@@ -1,5 +1,26 @@
 #include "compiler/IrOptimizer.h"
+#include "compiler/CError.h"
 #include "compiler/CParser.h"
+#include "compiler/InlineAsmPPC.h"
+#include "compiler/IroCSE.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroEval.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroSubable.h"
+#include "compiler/IroTransform.h"
+#include "compiler/IROUseDef.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/objects.h"
+#include "compiler/IroPropagate.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IroJump.h"
+#include "compiler/IroRangePropagation.h"
+#include "compiler/IroEmptyLoop.h"
+#include "compiler/IroUnrollLoop.h"
+#include "compiler/IroLoop.h"
+#include "compiler/IroExprRegeneration.h"
 
 Boolean DoScalarize;
 Boolean DoLinearize;
@@ -9,37 +30,367 @@ Boolean VectorPhaseCalledFromUnroll;
 Boolean IRO_Log;
 static Boolean stIsSetup;
 
-static void CountRefToObject() {
+static void CountRefToObject(Object *object, int depth) {
+    static unsigned short LoopUsage[] = {1, 4, 16, 64};
+
+    if (depth > 3)
+        depth = 3;
+
+    object->u.var.info->usage += LoopUsage[depth];
+    object->u.var.info->used = 1;
 }
 
-static void CountARef() {
+static void CountARef(IROLinear *node, int depth) {
+    Object *object;
+
+    object = node->u.node->data.objref;
+    CError_ASSERT(78, object->datatype != DALIAS);
+
+    if (object->datatype == DLOCAL && object->u.var.info) {
+        CountRefToObject(object, depth);
+        if ((node->flags & IROLF_Used) && (node->flags & IROLF_Assigned))
+            CountRefToObject(object, depth);
+
+        if (!(node->flags & IROLF_Immind) && !object->u.var.info->noregister)
+            object->u.var.info->noregister = 2;
+    }
 }
 
-static void CountDoubleInd() {
+static void CountDoubleInd(IROLinear *node, int depth) {
+    if (IRO_IsVariable(node)) {
+        CountARef(node->u.monadic, depth);
+    } else if (node->type == IROLinearOp2Arg) {
+        if (node->nodetype == EADD) {
+            CountDoubleInd(node->u.diadic.left, depth);
+            CountDoubleInd(node->u.diadic.right, depth);
+        } else if (IRO_IsAddressMultiply(node)) {
+            if (IRO_IsVariable(node->u.diadic.left))
+                CountARef(node->u.diadic.left->u.monadic, depth);
+        }
+    }
 }
 
-static void CountUsage() {
+static void CountUsage(void) {
+    IRONode *fnode = IRO_FirstNode;
+    IROLinear *node;
+
+    if (IRO_FirstNode) {
+        for (; fnode; fnode = fnode->nextnode) {
+            for (node = fnode->first; node; node = node->next) {
+                if (IS_LINEAR_ENODE(node, EOBJREF))
+                    CountARef(node, fnode->loopdepth);
+                else if (IS_LINEAR_MONADIC(node, EINDIRECT))
+                    CountDoubleInd(node->u.monadic, fnode->loopdepth);
+
+                if (node->type == IROLinearAsm) {
+                    IAEffects effects;
+                    int i;
+
+                    CodeGen_GetAsmEffects(node->u.asm_stmt, &effects);
+                    for (i = 0; i < effects.numoperands; i++) {
+                        Object *object = effects.operands[i].object;
+                        if (object->datatype == DLOCAL && object->u.var.info) {
+                            CountRefToObject(object, fnode->loopdepth);
+                            if (effects.operands[i].type == IAOpnd_3 && !object->u.var.info->noregister)
+                                object->u.var.info->noregister = 2;
+                        }
+                    }
+                }
+
+                if (node == fnode->last)
+                    break;
+            }
+        }
+    } else {
+        for (node = IRO_FirstLinear; node; node = node->next) {
+            if (IS_LINEAR_ENODE(node, EOBJREF))
+                CountARef(node, 0);
+            else if (IS_LINEAR_MONADIC(node, EINDIRECT))
+                CountDoubleInd(node->u.monadic, 0);
+        }
+    }
+
+    IRO_CheckForUserBreak();
 }
 
-Statement *IRO_Optimizer(Object *obj, Statement *stmt) {
+Statement *IRO_Optimizer(Object *func, Statement *statements) {
+    Boolean changed;
+    Boolean changed2;
+    int pass;
+    int passCount;
+
+    CError_ASSERT(234, stIsSetup);
+
+    DisableDueToAsm = 0;
+    FunctionName = func;
+    DoScalarize = 1;
+    DoLinearize = 1;
+    EarlyReturn = 0;
+    IRO_Depends = NULL;
+    LoopOptimizerRun = 0;
+    IRO_IsLeafFunction = 1;
+    IRO_FunctionHasReturn = 0;
+
+    IRO_SetupForUserBreakChecking();
+
+    IRO_Dump("Starting function %s\n", func ? func->name->name : "Init-code");
+    IRO_Dump("--------------------------------------------------------------------------------\n");
+
+    if (DoLinearize)
+        IRO_PreLinearize(statements);
+    if (copts.optimizationlevel > 0)
+        IRO_TransformTree(statements);
+
+    VectorPhaseCalledFromUnroll = 0;
+
+    IRO_Linearize(statements);
+
+    CurStat = NULL;
+
+    IRO_FirstExpr = NULL;
+    IRO_LastExpr = NULL;
+    IRO_FirstAssign = NULL;
+    IRO_LastAssign = NULL;
+    IRO_FirstVarUse = NULL;
+    IRO_LastVarUse = NULL;
+    IRO_FirstNode = NULL;
+    IRO_LastNode = NULL;
+
+    if (copts.optimizationlevel > 0)
+        IRO_DoTransformations();
+
+    IRO_BuildFlowgraph(IRO_FirstLinear);
+    IRO_DumpAfterPhase("IRO_BuildflowGraph", 0);
+
+    IRO_FindAllVars();
+    IRO_CheckInit();
+
+    if (!DisableDueToAsm && copts.optimizationlevel > 0 && copts.opt_pointer_analysis && func) {
+        IRO_AnalyzePointers(func);
+        if (copts.opt_propagation && IRO_EvaluateDefinitePointers(func)) {
+            IRO_UpdateFlagsOnInts();
+            IRO_UpdateVars();
+            IRO_DumpAfterPhase("IRO_EvaluateDefinitePointers", 0);
+        }
+    }
+
+    if (copts.optimizationlevel > 0) {
+        changed = IRO_EvaluateConditionals();
+
+        if (!DisableDueToAsm) {
+            changed |= IRO_RemoveUnreachable();
+            IRO_DumpAfterPhase("IRO_RemoveUnreachable", 0);
+        }
+
+        changed |= IRO_RemoveRedundantJumps();
+        IRO_DumpAfterPhase("IRO_RemoveRedundantJumps", 0);
+
+        if (!DisableDueToAsm) {
+            changed |= IRO_RemoveLabels();
+            IRO_DumpAfterPhase("IRO_RemoveLabels()", 0);
+        }
+
+        if (changed) {
+            IRO_BuildFlowgraph(IRO_FirstLinear);
+            IRO_DumpAfterPhase("IRO_BuildflowGraph--1", 0);
+        }
+    }
+
+    if (!DisableDueToAsm && copts.optimizationlevel > 0) {
+        passCount = copts._B4 ? 2 : 1;
+        IRO_CPFirstTime = 1;
+        for (pass = 0; pass < passCount; pass++) {
+            IRO_Dump("*****************\n");
+            IRO_Dump("Dumps for pass=%d\n", pass);
+            IRO_Dump("*****************\n");
+
+            if (DoScalarize)
+                IRO_ScalarizeClassDataMembers();
+            IRO_DumpAfterPhase("IRO_ScalarizeClassDataMembers", 0);
+
+            if (copts.opt_propagation) {
+                IRO_CopyAndConstantPropagation();
+                IRO_CPFirstTime = 0;
+                IRO_ExpressionPropagation();
+                IRO_DumpAfterPhase("Copy and constant propagation", 0);
+
+                IRO_RangePropagateInFNode();
+                IRO_DumpAfterPhase("IRO_RangePropagateInFNode", 0);
+                IRO_UpdateFlagsOnInts();
+            }
+
+            IRO_DumpAfterPhase("IRO_ExpressionPropagation", 0);
+
+            if (copts.opt_dead_assignments || copts.opt_propagation)
+                IRO_UseDef(copts.opt_dead_assignments, copts.opt_propagation);
+            IRO_DumpAfterPhase("after IRO_UseDef", 0);
+
+            IRO_UpdateVars();
+            IRO_ConstantFolding();
+            IRO_DumpAfterPhase("IRO_ConstantFolding", 0);
+
+            IRO_EvaluateConditionals();
+            IRO_RemoveUnreachable();
+            IRO_SimplifyConditionals();
+
+            if (pass == 1 && copts.optimizationlevel > 2) {
+                IRO_RenumberInts();
+                IRO_DumpAfterPhase("Before IRO_FindEmptyLoops", 0);
+                IRO_FindEmptyLoops();
+                IRO_DumpAfterPhase("After IRO_FindEmptyLoops", 0);
+                IRO_RenumberInts();
+            }
+
+            if (copts.opt_unroll_loops && !copts.optimize_for_size && pass == 0) {
+                IRO_DumpAfterPhase("Before IRO_LoopUnroller", 0);
+                IRO_LoopUnroller();
+                IRO_DumpAfterPhase("After IRO_LoopUnroller", 0);
+                IRO_RenumberInts();
+            }
+
+            VectorPhaseCalledFromUnroll = 0;
+
+            if (pass == 0 && (copts.opt_loop_invariants || copts.opt_strength_reduction)) {
+                IRO_DumpAfterPhase("Before IRO_FindLoops", 0);
+                IRO_FindLoops();
+                LoopOptimizerRun = 1;
+                IRO_SetLoopDepth();
+            }
+            IRO_DumpAfterPhase("After IRO_FindLoops", 0);
+
+            if (copts.opt_propagation) {
+                IRO_CopyAndConstantPropagation();
+                IRO_ConstantFolding();
+                IRO_EvaluateConditionals();
+            }
+
+            IRO_DumpAfterPhase("Second pass:IRO_CopyAndConstantPropagation, IRO_ConstantFolding, IRO_EvaluateConditionals", 0);
+
+            if (copts.opt_common_subs)
+                IRO_FindExpressions(NULL, 0);
+
+            if (copts.opt_common_subs) {
+                IRO_ComputeAvail();
+                IRO_CommonSubs();
+            }
+            IRO_DumpAfterPhase("IRO_CommonSubs", 0);
+
+            IRO_UpdateFlagsOnInts();
+            IRO_UpdateVars();
+            IRO_DoTransformations();
+            IRO_ConstantFolding();
+
+            do {
+                IRO_UpdateFlagsOnInts();
+
+                if (copts.opt_dead_code)
+                    IRO_RemoveUnreachable();
+                IRO_DumpAfterPhase("IRO_RemoveUnreachable", 0);
+
+                changed2 = IRO_RemoveRedundantJumps();
+                IRO_DumpAfterPhase("IRO_RemoveRedundantJumps", 0);
+
+                changed2 |= IRO_RemoveLabels();
+                IRO_DumpAfterPhase("IRO_RemoveLabels", 0);
+
+                changed2 |= IRO_DoJumpChaining();
+                IRO_DumpAfterPhase("IRO_DoJumpChaining", 0);
+
+                if (copts.opt_propagation) {
+                    IRO_RenumberInts();
+                    IRO_DumpAfterPhase("Before IRO_CopyAndConstantPropagation", 0);
+                    changed2 |= IRO_CopyAndConstantPropagation();
+                    IRO_DumpAfterPhase("After IRO_CopyAndConstantPropagation", 0);
+                    IRO_ConstantFolding();
+                }
+
+                if (copts.opt_dead_assignments || copts.opt_propagation)
+                    changed2 |= IRO_UseDef(copts.opt_dead_assignments, copts.opt_propagation);
+                IRO_DumpAfterPhase("IRO_UseDef", 0);
+
+                changed2 |= IRO_EvaluateConditionals();
+                IRO_DumpAfterPhase("IRO_EvaluateConditionals", 0);
+            } while (changed2);
+        }
+
+        if (copts.opt_lifetimes) {
+            IRO_UseDef(0, 0);
+            IRO_SplitLifetimes();
+        }
+
+        IRO_DoTransformations();
+        IRO_DumpAfterPhase("Before RebuildCondExpressions", 0);
+    }
+
+    IRO_RenumberInts();
+    IRO_DumpAfterPhase("before IRO_RewriteBitFieldTemps", 0);
+    IRO_RewriteBitFieldTemps();
+    IRO_DumpAfterPhase("After IRO_RewriteBitFieldTemps", 0);
+
+    CountUsage();
+
+    if (!DisableDueToAsm) {
+        IRO_RegenerateExpressions();
+        IRO_DumpAfterPhase("IRO_RegenerateExpressions", 0);
+    }
+
+    IRO_DumpAfterPhase("After IRO_Optimizer", 0);
+
+    statements = IRO_Delinearize(IRO_FirstNode, NULL);
+
+    IRO_ZapVarPtrs();
+    freeoheap();
+    return statements;
 }
 
 void IRO_Setup(void) {
     static Boolean ENodeArraysHaveBeenInitialized;
+
+    if (!stIsSetup) {
+        IRO_Log = 0;
+        IRO_SetupDump();
+        if (!ENodeArraysHaveBeenInitialized) {
+            IRO_InitializeNodeNamesArray();
+            IRO_InitializeIsAssociativeENodeTypeArray();
+            IRO_InitializeIsSubableOpArray();
+            IRO_InitializeAssignmentOpArray();
+            IRO_InitializeComplementaryOpArray();
+            IRO_InitializeComplementaryOpLogicalArray();
+            IRO_InitializeNonAssignmentOpArray();
+            IRO_InitializeAssignmentFoldingFunctionArray();
+            IRO_InitializeIRO_IsModifyOpArray();
+            IRO_InitializeIRO_IsAssignOpArray();
+            ENodeArraysHaveBeenInitialized = 1;
+        }
+        stIsSetup = 1;
+    }
 }
 
 void IRO_Cleanup(void) {
+    if (stIsSetup) {
+        IRO_CleanupDump();
+        stIsSetup = 0;
+    }
 }
 
 void CodeGen_UpdateOptimizerOptions(void) {
-    copts.opt_dead_code = copts.optimizationlevel > 0;
-    copts.opt_propagation = copts.optimizationlevel > 1;
-    copts.opt_common_subs = copts.optimizationlevel > 1;
-    copts.opt_vectorize_loops = copts.optimizationlevel > 2;
-    copts.opt_unroll_loops = copts.optimizationlevel > 2;
-    copts.opt_dead_assignments = copts.optimizationlevel > 2;
-    copts.opt_lifetimes = copts.optimizationlevel > 2;
-    copts.opt_strength_reduction = copts.optimizationlevel > 2;
-    copts.opt_loop_invariants = copts.optimizationlevel > 2;
-    copts._B4 = copts.optimizationlevel > 3;
+    Boolean flag;
+
+    flag = copts.optimizationlevel >= 1;
+    copts.opt_dead_code = flag;
+
+    flag = copts.optimizationlevel >= 2;
+    copts.opt_propagation = flag;
+    copts.opt_common_subs = flag;
+
+    flag = copts.optimizationlevel >= 3;
+    copts.opt_vectorize_loops = flag;
+    copts.opt_unroll_loops = flag;
+    copts.opt_dead_assignments = flag;
+    copts.opt_lifetimes = flag;
+    copts.opt_strength_reduction = flag;
+    copts.opt_loop_invariants = flag;
+
+    flag = copts.optimizationlevel >= 4;
+    copts._B4 = flag;
 }
diff --git a/compiler_and_linker/unsorted/IroCSE.c b/compiler_and_linker/unsorted/IroCSE.c
index dd82716..2311786 100644
--- a/compiler_and_linker/unsorted/IroCSE.c
+++ b/compiler_and_linker/unsorted/IroCSE.c
@@ -5,6 +5,7 @@
 #include "compiler/IroMalloc.h"
 #include "compiler/IroPointerAnalysis.h"
 #include "compiler/IroSubable.h"
+#include "compiler/IROUseDef.h"
 #include "compiler/IroUtil.h"
 #include "compiler/IroVars.h"
 #include "compiler/CError.h"
@@ -979,10 +980,22 @@ void IRO_CommonSubs(void) {
     IRO_CheckForUserBreak();
 }
 
-static Boolean CountThisSubableOperandUse() {
+static Boolean CountThisSubableOperandUse(IROUse *use) {
+    return use->x1C != 0;
 }
 
-static void GetSubableOperandUseCount() {
+static int GetSubableOperandUseCount(VarRecord *var) {
+    int count = 0;
+    IROUse *use;
+
+    if (var->uses) {
+        for (use = var->uses; use; use = use->varnext) {
+            if (CountThisSubableOperandUse(use))
+                count++;
+        }
+    }
+
+    return count;
 }
 
 static void IRO_MakeTopLevelExprForSubableOperand(IROLinear *linear) {
diff --git a/compiler_and_linker/unsorted/IroEval.c b/compiler_and_linker/unsorted/IroEval.c
index e69de29..a34cf89 100644
--- a/compiler_and_linker/unsorted/IroEval.c
+++ b/compiler_and_linker/unsorted/IroEval.c
@@ -0,0 +1,914 @@
+#include "compiler/IroEval.h"
+#include "compiler/CInt64.h"
+#include "compiler/CMachine.h"
+#include "compiler/CParser.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroMalloc.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/enode.h"
+#include "compiler/objects.h"
+#include "compiler/types.h"
+
+static Boolean IsAssociativeENodeType[MAXEXPR];
+
+void IRO_InitializeIsAssociativeENodeTypeArray(void) {
+    int i;
+
+    for (i = 0; i < MAXEXPR; i++)
+        IsAssociativeENodeType[i] = 0;
+
+    IsAssociativeENodeType[EPOSTINC] = 0;
+    IsAssociativeENodeType[EPOSTDEC] = 0;
+    IsAssociativeENodeType[EPREINC] = 0;
+    IsAssociativeENodeType[EPREDEC] = 0;
+    IsAssociativeENodeType[EINDIRECT] = 0;
+    IsAssociativeENodeType[EMONMIN] = 0;
+    IsAssociativeENodeType[EBINNOT] = 0;
+    IsAssociativeENodeType[ELOGNOT] = 0;
+    IsAssociativeENodeType[EFORCELOAD] = 0;
+    IsAssociativeENodeType[EMUL] = 1;
+    IsAssociativeENodeType[EMULV] = 1;
+    IsAssociativeENodeType[EDIV] = 0;
+    IsAssociativeENodeType[EMODULO] = 0;
+    IsAssociativeENodeType[EADDV] = 1;
+    IsAssociativeENodeType[ESUBV] = 0;
+    IsAssociativeENodeType[EADD] = 1;
+    IsAssociativeENodeType[ESUB] = 0;
+    IsAssociativeENodeType[ESHL] = 0;
+    IsAssociativeENodeType[ESHR] = 0;
+    IsAssociativeENodeType[ELESS] = 0;
+    IsAssociativeENodeType[EGREATER] = 0;
+    IsAssociativeENodeType[ELESSEQU] = 0;
+    IsAssociativeENodeType[EGREATEREQU] = 0;
+    IsAssociativeENodeType[EEQU] = 0;
+    IsAssociativeENodeType[ENOTEQU] = 0;
+    IsAssociativeENodeType[EAND] = 1;
+    IsAssociativeENodeType[EXOR] = 1;
+    IsAssociativeENodeType[EOR] = 1;
+    IsAssociativeENodeType[ELAND] = 0;
+    IsAssociativeENodeType[ELOR] = 0;
+    IsAssociativeENodeType[EASS] = 0;
+    IsAssociativeENodeType[EMULASS] = 0;
+    IsAssociativeENodeType[EDIVASS] = 0;
+    IsAssociativeENodeType[EMODASS] = 0;
+    IsAssociativeENodeType[EADDASS] = 0;
+    IsAssociativeENodeType[ESUBASS] = 0;
+    IsAssociativeENodeType[ESHLASS] = 0;
+    IsAssociativeENodeType[ESHRASS] = 0;
+    IsAssociativeENodeType[EANDASS] = 0;
+    IsAssociativeENodeType[EXORASS] = 0;
+    IsAssociativeENodeType[EORASS] = 0;
+    IsAssociativeENodeType[ECOMMA] = 0;
+    IsAssociativeENodeType[EPMODULO] = 0;
+    IsAssociativeENodeType[EROTL] = 0;
+    IsAssociativeENodeType[EROTR] = 0;
+    IsAssociativeENodeType[EBCLR] = 0;
+    IsAssociativeENodeType[EBTST] = 0;
+    IsAssociativeENodeType[EBSET] = 0;
+    IsAssociativeENodeType[ETYPCON] = 0;
+    IsAssociativeENodeType[EBITFIELD] = 0;
+    IsAssociativeENodeType[EINTCONST] = 0;
+    IsAssociativeENodeType[EFLOATCONST] = 0;
+    IsAssociativeENodeType[ESTRINGCONST] = 0;
+    IsAssociativeENodeType[ECOND] = 0;
+    IsAssociativeENodeType[EFUNCCALL] = 0;
+    IsAssociativeENodeType[EFUNCCALLP] = 0;
+    IsAssociativeENodeType[EOBJREF] = 0;
+    IsAssociativeENodeType[EMFPOINTER] = 0;
+    IsAssociativeENodeType[ENULLCHECK] = 0;
+    IsAssociativeENodeType[EPRECOMP] = 0;
+    IsAssociativeENodeType[ETEMP] = 0;
+    IsAssociativeENodeType[EARGOBJ] = 0;
+    IsAssociativeENodeType[ELOCOBJ] = 0;
+    IsAssociativeENodeType[ELABEL] = 0;
+    IsAssociativeENodeType[ESETCONST] = 0;
+    IsAssociativeENodeType[ENEWEXCEPTION] = 0;
+    IsAssociativeENodeType[ENEWEXCEPTIONARRAY] = 0;
+    IsAssociativeENodeType[EOBJLIST] = 0;
+    IsAssociativeENodeType[EMEMBER] = 0;
+    IsAssociativeENodeType[ETEMPLDEP] = 0;
+    IsAssociativeENodeType[EINSTRUCTION] = 0;
+    IsAssociativeENodeType[EDEFINE] = 0;
+    IsAssociativeENodeType[EREUSE] = 0;
+    IsAssociativeENodeType[EASSBLK] = 0;
+    IsAssociativeENodeType[EVECTOR128CONST] = 0;
+    IsAssociativeENodeType[ECONDASS] = 0;
+}
+
+void IRO_TruncateValueToType(CInt64 *val, Type *type) {
+    if (IRO_IsUnsignedType(type)) {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertUInt8(val);
+                break;
+            case 2:
+                CInt64_ConvertUInt16(val);
+                break;
+            case 4:
+                CInt64_ConvertUInt32(val);
+                break;
+        }
+    } else {
+        switch (type->size) {
+            case 1:
+                CInt64_ConvertInt8(val);
+                break;
+            case 2:
+                CInt64_ConvertInt16(val);
+                break;
+            case 4:
+                CInt64_ConvertInt32(val);
+                break;
+        }
+    }
+}
+
+void IRO_TruncateBitfieldValueToType(CInt64 *val, Type *type, Type *type2) {
+    UInt32 limit;
+    UInt32 i;
+    UInt32 j;
+    CInt64 work;
+
+    work = cint64_zero;
+    limit = TYPE_BITFIELD(type2)->unkB;
+    for (i = 0; i < limit; i++)
+        work = CInt64_Or(work, CInt64_Shl(cint64_one, IRO_MakeULong(i)));
+    *val = CInt64_And(*val, work);
+
+    if (!IRO_IsUnsignedType(type)) {
+        work = cint64_zero;
+        for (j = 0; j <= (i - 1); j++) {
+            if (j == (i - 1))
+                work = CInt64_Or(work, CInt64_Shl(cint64_one, IRO_MakeULong(j)));
+        }
+        if (CInt64_NotEqual(CInt64_And(work, *val), cint64_zero)) {
+            for (j = i - 1; j < 64; j++)
+                *val = CInt64_Or(*val, CInt64_Shl(cint64_one, IRO_MakeULong(j)));
+        }
+    }
+
+    IRO_TruncateValueToType(val, type);
+}
+
+void IRO_ConstantFolding(void) {
+    IROLinear *nd;
+    ENode *expr;
+    int isCompare;
+    int flag;
+    CInt64 val;
+
+    for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+        switch (nd->type) {
+            case IROLinearOp1Arg:
+                if (IRO_IsIntConstant(nd->u.monadic)) {
+                    expr = NULL;
+                    flag = 0;
+                    val = nd->u.monadic->u.node->data.intval;
+                    if (nd->nodetype == ETYPCON && IS_TYPE_FLOAT(nd->rtype)) {
+                        expr = IRO_NewENode(EFLOATCONST);
+                        if (!IRO_IsUnsignedType(nd->u.monadic->rtype))
+                            expr->data.floatval.value = CInt64_ConvertToLongDouble(&val);
+                        else
+                            expr->data.floatval.value = CInt64_ConvertUToLongDouble(&val);
+                        expr->rtype = nd->rtype;
+                    } else {
+                        switch (nd->nodetype) {
+                            case ETYPCON:
+                                flag = 1;
+                                break;
+                            case ELOGNOT:
+                                val = CInt64_Not(val);
+                                flag = 1;
+                                break;
+                            case EBINNOT:
+                                val = CInt64_Inv(val);
+                                flag = 1;
+                                break;
+                            case EMONMIN:
+                                val = CInt64_Neg(val);
+                                flag = 1;
+                                break;
+                        }
+
+                        if (flag) {
+                            IRO_TruncateValueToType(&val, nd->rtype);
+                            expr = IRO_NewENode(EINTCONST);
+                            expr->rtype = nd->rtype;
+                            expr->data.intval = val;
+                        }
+                    }
+
+                    if (expr) {
+                        nd->u.monadic->type = IROLinearNop;
+                        nd->type = IROLinearOperand;
+                        nd->u.node = expr;
+                    }
+                }
+                break;
+
+            case IROLinearOp2Arg:
+                if (IRO_IsIntConstant(nd->u.diadic.left) && !IRO_IsIntConstant(nd->u.diadic.right) && IsAssociativeENodeType[nd->nodetype]) {
+                    IROLinear *tmp = nd->u.diadic.right;
+                    nd->u.diadic.right = nd->u.diadic.left;
+                    nd->u.diadic.left = tmp;
+                }
+
+                if (IRO_IsIntConstant(nd->u.diadic.right) && nd->nodetype == ESUB) {
+                    nd->nodetype = EADD;
+                    if (IRO_IsIntConstant(nd->u.diadic.right)) {
+                        CInt64 v;
+                        v = CInt64_Neg(nd->u.diadic.right->u.node->data.intval);
+                        nd->u.diadic.right->u.node->data.intval = v;
+                    } else {
+                        Float f;
+                        f = CMach_CalcFloatMonadic(
+                            nd->u.diadic.right->rtype,
+                            '-',
+                            nd->u.diadic.right->u.node->data.floatval);
+                        nd->u.diadic.right->u.node->data.floatval = f;
+                    }
+                }
+
+                if (
+                    IRO_IsIntConstant(nd->u.diadic.right) &&
+                    IsAssociativeENodeType[nd->nodetype] &&
+                    nd->u.diadic.left->type == IROLinearOp2Arg &&
+                    nd->u.diadic.left->nodetype == nd->nodetype &&
+                    nd->u.diadic.left->rtype == nd->rtype &&
+                    IRO_IsIntConstant(nd->u.diadic.left->u.diadic.right) &&
+                    nd->u.diadic.left->u.diadic.right->rtype == nd->u.diadic.right->rtype
+                    )
+                {
+                    IROLinear *tmp = nd->u.diadic.left;
+                    nd->u.diadic.left = tmp->u.diadic.left;
+                    tmp->u.diadic.left = tmp->u.diadic.right;
+                    tmp->u.diadic.right = nd->u.diadic.right;
+                    tmp->rtype = tmp->u.diadic.left->rtype;
+                    nd->u.diadic.right = tmp;
+                    nd = tmp;
+                }
+
+                if (IRO_IsIntConstant(nd->u.diadic.left) && IRO_IsIntConstant(nd->u.diadic.right)) {
+                    CInt64 val1 = nd->u.diadic.left->u.node->data.intval;
+                    CInt64 val2 = nd->u.diadic.right->u.node->data.intval;
+                    flag = 0;
+                    switch (nd->nodetype) {
+                        case EADD:
+                            val = CInt64_Add(val1, val2);
+                            flag = 1;
+                            break;
+                        case ESUB:
+                            val = CInt64_Sub(val1, val2);
+                            flag = 1;
+                            break;
+                        case EMUL:
+                            if (IRO_IsUnsignedType(nd->rtype))
+                                val = CInt64_MulU(val1, val2);
+                            else
+                                val = CInt64_Mul(val1, val2);
+                            flag = 1;
+                            break;
+                        case EDIV:
+                            if (!CInt64_IsZero(&val2)) {
+                                if (IRO_IsUnsignedType(nd->rtype))
+                                    val = CInt64_DivU(val1, val2);
+                                else
+                                    val = CInt64_Div(val1, val2);
+                                flag = 1;
+                            }
+                            break;
+                        case EMODULO:
+                            if (!CInt64_IsZero(&val2)) {
+                                if (IRO_IsUnsignedType(nd->rtype))
+                                    val = CInt64_ModU(val1, val2);
+                                else
+                                    val = CInt64_Mod(val1, val2);
+                                flag = 1;
+                            }
+                            break;
+                        case ESHL:
+                            val = CInt64_Shl(val1, val2);
+                            flag = 1;
+                            break;
+                        case ESHR:
+                            if (IRO_IsUnsignedType(nd->rtype))
+                                val = CInt64_ShrU(val1, val2);
+                            else
+                                val = CInt64_Shr(val1, val2);
+                            flag = 1;
+                            break;
+                        case EAND:
+                            val = CInt64_And(val1, val2);
+                            flag = 1;
+                            break;
+                        case EOR:
+                            val = CInt64_Or(val1, val2);
+                            flag = 1;
+                            break;
+                        case EXOR:
+                            val = CInt64_Xor(val1, val2);
+                            flag = 1;
+                            break;
+                        case ELESS:
+                            if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+                                CInt64_SetULong(&val, CInt64_LessU(val1, val2));
+                            else
+                                CInt64_SetULong(&val, CInt64_Less(val1, val2));
+                            flag = 1;
+                            break;
+                        case EGREATER:
+                            if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+                                CInt64_SetULong(&val, CInt64_GreaterU(val1, val2));
+                            else
+                                CInt64_SetULong(&val, CInt64_Greater(val1, val2));
+                            flag = 1;
+                            break;
+                        case ELESSEQU:
+                            if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+                                CInt64_SetULong(&val, CInt64_LessEqualU(val1, val2));
+                            else
+                                CInt64_SetULong(&val, CInt64_LessEqual(val1, val2));
+                            flag = 1;
+                            break;
+                        case EGREATEREQU:
+                            if (IRO_IsUnsignedType(nd->u.diadic.left->rtype))
+                                CInt64_SetULong(&val, CInt64_GreaterEqualU(val1, val2));
+                            else
+                                CInt64_SetULong(&val, CInt64_GreaterEqual(val1, val2));
+                            flag = 1;
+                            break;
+                        case EEQU:
+                            CInt64_SetULong(&val, CInt64_Equal(val1, val2));
+                            flag = 1;
+                            break;
+                        case ENOTEQU:
+                            CInt64_SetULong(&val, CInt64_NotEqual(val1, val2));
+                            flag = 1;
+                            break;
+                    }
+
+                    if (flag) {
+                        IRO_TruncateValueToType(&val, nd->rtype);
+                        expr = IRO_NewENode(EINTCONST);
+                        expr->rtype = nd->rtype;
+                        expr->data.intval = val;
+                        nd->u.diadic.left->type = IROLinearNop;
+                        nd->u.diadic.right->type = IROLinearNop;
+                        nd->type = IROLinearOperand;
+                        nd->u.node = expr;
+                    }
+                }
+
+                if (IRO_IsFloatConstant(nd->u.diadic.left) && IRO_IsFloatConstant(nd->u.diadic.right)) {
+                    Float fval1 = nd->u.diadic.left->u.node->data.floatval;
+                    Float fval2 = nd->u.diadic.right->u.node->data.floatval;
+                    Float fval;
+                    flag = 0;
+                    isCompare = 0;
+                    switch (nd->nodetype) {
+                        case EADD:
+                            fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '+', fval2);
+                            flag = 1;
+                            break;
+                        case ESUB:
+                            fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '-', fval2);
+                            flag = 1;
+                            break;
+                        case EMUL:
+                            fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '*', fval2);
+                            flag = 1;
+                            break;
+                        case EDIV:
+                            fval = CMach_CalcFloatDiadic(nd->rtype, fval1, '/', fval2);
+                            flag = 1;
+                            break;
+                        case ELESS:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, '<', fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                        case EGREATER:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, '>', fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                        case ELESSEQU:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LESS_EQUAL, fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                        case EGREATEREQU:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_GREATER_EQUAL, fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                        case EEQU:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LOGICAL_EQ, fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                        case ENOTEQU:
+                            CInt64_SetULong(&val, CMach_CalcFloatDiadicBool(nd->rtype, fval1, TK_LOGICAL_NE, fval2));
+                            flag = 1;
+                            isCompare = 1;
+                            break;
+                    }
+
+                    if (flag) {
+                        if (isCompare) {
+                            IRO_TruncateValueToType(&val, nd->rtype);
+                            expr = IRO_NewENode(EINTCONST);
+                            expr->rtype = nd->rtype;
+                            expr->data.intval = val;
+                            nd->u.diadic.left->type = IROLinearNop;
+                            nd->u.diadic.right->type = IROLinearNop;
+                            nd->type = IROLinearOperand;
+                            nd->u.node = expr;
+                        } else {
+                            expr = IRO_NewENode(EFLOATCONST);
+                            expr->rtype = nd->rtype;
+                            expr->data.floatval = fval;
+                            nd->u.diadic.left->type = IROLinearNop;
+                            nd->u.diadic.right->type = IROLinearNop;
+                            nd->type = IROLinearOperand;
+                            nd->u.node = expr;
+                        }
+                    }
+                }
+
+                break;
+        }
+    }
+
+    IRO_CheckForUserBreak();
+}
+
+Boolean IRO_EvaluateConditionals(void) {
+    IRONode *fnode;
+    IROLinear *nd;
+    Boolean changed = 0;
+    SwitchInfo *switchInfo;
+    SwitchCase *swcase;
+    char found;
+    CInt64 val;
+
+    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
+        nd = fnode->last;
+        switch (nd->type) {
+            case IROLinearIf:
+            case IROLinearIfNot:
+                if (IRO_IsIntConstant(nd->u.label.x4)) {
+                    Boolean isZero = CInt64_IsZero(&nd->u.label.x4->u.node->data.intval);
+                    IRO_NopOut(nd->u.label.x4);
+                    if ((isZero == 0) == (nd->type == IROLinearIf))
+                        nd->type = IROLinearGoto;
+                    else
+                        nd->type = IROLinearNop;
+                    changed = 1;
+                }
+                break;
+
+            case IROLinearSwitch:
+                if (IRO_IsIntConstant(nd->u.swtch.x4)) {
+                    val = nd->u.swtch.x4->u.node->data.intval;
+                    switchInfo = nd->u.swtch.info;
+                    swcase = switchInfo->cases;
+
+                    IRO_NopOut(nd->u.swtch.x4);
+                    nd->type = IROLinearGoto;
+
+                    found = 0;
+                    while (swcase) {
+                        if (CInt64_GreaterEqual(val, swcase->min) && CInt64_LessEqual(val, swcase->max)) {
+                            found = 1;
+                            nd->u.label.label = swcase->label;
+                            break;
+                        }
+                        swcase = swcase->next;
+                    }
+
+                    if (!found)
+                        nd->u.label.label = switchInfo->defaultlabel;
+                    changed = 1;
+                }
+                break;
+        }
+    }
+
+    if (changed) {
+        IRO_ComputeSuccPred();
+        IRO_ComputeDom();
+    }
+    IRO_CheckForUserBreak();
+
+    return changed;
+}
+
+static int EEquConst(IROLinear *nd) {
+    return nd && (nd->nodetype == EEQU) && IRO_IsIntConstant(nd->u.diadic.right);
+}
+
+static Object *VEquConst(IROLinear *nd) {
+    if (EEquConst(nd))
+        return IRO_IsVariable(nd->u.diadic.left);
+    else
+        return NULL;
+}
+
+static int IsConsecutive(CInt64 a, CInt64 b) {
+    CInt64 diff;
+
+    if (!CInt64_Equal(a, cint64_min) && !CInt64_Equal(b, cint64_min)) {
+        diff = CInt64_Sub(b, a);
+        return CInt64_Equal(diff, cint64_one) || CInt64_Equal(diff, cint64_negone);
+    }
+
+    return 0;
+}
+
+static IROLinear *findLabel(CLabel *label) {
+    IROLinear *nd;
+
+    for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+        if (nd->type == IROLinearLabel && nd->u.label.label == label)
+            break;
+    }
+
+    return nd;
+}
+
+static IROLinear *leftLeaveOf(IROLinear *nd) {
+    switch (nd->type) {
+        case IROLinearOp1Arg:
+            return leftLeaveOf(nd->u.monadic);
+        case IROLinearOp2Arg:
+            return leftLeaveOf(nd->u.diadic.left);
+        case IROLinearOperand:
+            return nd;
+        default:
+            return NULL;
+    }
+}
+
+static int checkNode(IRONode *fnode) {
+    IROLinear *nd;
+
+    if (fnode->numpred <= 1) {
+        nd = fnode->first;
+        while (nd != fnode->last && (nd->type == IROLinearNop || nd->type == IROLinearLabel))
+            nd = nd->next;
+
+        if (nd == leftLeaveOf(fnode->last->u.label.x4))
+            return 1;
+    }
+
+    return 0;
+}
+
+static int checkLabel(CLabel *label, IRONode *fnode) {
+    switch (fnode->last->type) {
+        case IROLinearIf:
+            if (label == fnode->last->u.label.label)
+                return 1;
+            break;
+    }
+
+    return 0;
+}
+
+static Object *checkExpr(Object *a, IROLinear *nd) {
+    Object *b = VEquConst(nd);
+
+    if ((!a || a == b) && !IRO_HasSideEffect(nd))
+        return b;
+
+    return NULL;
+}
+
+static int checkStruct(IRONode *fnode1, IRONode *fnode2) {
+    CLabel *label;
+    Object *var;
+
+    if (fnode1 == fnode2)
+        return (int) checkExpr(NULL, fnode1->last->u.label.x4);
+
+    label = fnode1->last->u.label.label;
+    var = IRO_IsVariable(fnode1->last->u.label.x4->u.monadic);
+    return checkNode(fnode2) && checkLabel(label, fnode2) && checkExpr(var, fnode2->last->u.label.x4);
+}
+
+typedef struct ReduceInfo {
+    int x0;
+    int x4;
+    Object *x8;
+    IRONode *fnode;
+    struct ReduceInfo *next;
+    CInt64 val;
+} ReduceInfo;
+
+static int MarkPattern1(ReduceInfo *info1, ReduceInfo *info2, CInt64 *val) {
+    ReduceInfo *scan;
+
+    if (!info2)
+        return 0;
+
+    if (info2->x0)
+        return MarkPattern1(info1, info2->next, val);
+
+    for (scan = info1; scan; scan = scan->next) {
+        if (scan->x0 == 2) {
+            if (CInt64_Equal(info2->val, scan->val)) {
+                IRO_NopOut(scan->fnode->last);
+                IRO_NopOut(scan->fnode->last->u.label.x4); // right union?
+                scan->x0 = -1;
+                return MarkPattern1(info1, info2->next, val);
+            }
+
+            if (IsConsecutive(info2->val, scan->val)) {
+                info2->x0 = 2;
+                if (CInt64_Greater(*val, scan->val))
+                    *val = scan->val;
+                if (CInt64_Greater(*val, info2->val))
+                    *val = info2->val;
+                MarkPattern1(scan->next, info2, val);
+                MarkPattern1(info1, info1->next, val);
+                return 1;
+            }
+        }
+    }
+
+    return MarkPattern1(info1, info2->next, val);
+}
+
+static int DoReducible1(ReduceInfo *info, CInt64 val) {
+    ReduceInfo *last;
+    ReduceInfo *scan;
+    IROLinear *right;
+    IROLinear *left;
+    IROLinear *typconRight;
+    IROLinear *typconLeft;
+    IROLinear *cond;
+    int count;
+
+    count = 0;
+    for (scan = info; scan; scan = scan->next) {
+        if (scan->x0 == 2) {
+            last = scan;
+            count++;
+        }
+    }
+
+    if (!count)
+        return 0;
+
+    for (scan = info; scan != last; scan = scan->next) {
+        if (scan->x0 == 2) {
+            scan->x0 = -1;
+            IRO_NopOut(scan->fnode->last);
+            IRO_NopOut(scan->fnode->last->u.label.x4);
+        }
+    }
+
+    last->x0 = -1;
+
+    cond = last->fnode->last;
+    cond->u.label.x4->nodetype = ELESSEQU;
+    CInt64_SetULong(&cond->u.label.x4->u.diadic.right->u.node->data.intval, count - 1);
+
+    typconLeft = IRO_NewLinear(IROLinearOp1Arg);
+    typconLeft->nodetype = ETYPCON;
+    typconLeft->rtype = IRO_UnsignedType(cond->u.label.x4->u.diadic.left->rtype);
+    typconLeft->index = ++IRO_NumLinear;
+
+    typconRight = IRO_NewLinear(IROLinearOp1Arg);
+    *typconRight = *typconLeft;
+    typconRight->index = ++IRO_NumLinear;
+
+    left = IRO_NewLinear(IROLinearOp2Arg);
+    left->nodetype = EADD;
+    left->rtype = cond->u.label.x4->u.diadic.left->rtype;
+    left->index = ++IRO_NumLinear;
+
+    right = IRO_NewLinear(IROLinearOperand);
+    right->nodetype = EINTCONST;
+    right->rtype = cond->u.label.x4->u.diadic.left->rtype;
+    right->index = ++IRO_NumLinear;
+    right->u.node = IRO_NewENode(EINTCONST);
+    right->u.node->data.intval = CInt64_Neg(val);
+    right->u.node->rtype = right->rtype;
+
+    typconLeft->next = cond->u.label.x4->u.diadic.left->next;
+    cond->u.label.x4->u.diadic.left->next = right;
+    right->next = left;
+    left->next = typconLeft;
+
+    typconRight->next = cond->u.label.x4->u.diadic.right->next;
+    cond->u.label.x4->u.diadic.right->next = typconRight;
+
+    typconLeft->u.monadic = left;
+    left->u.diadic.left = cond->u.label.x4->u.diadic.left;
+    left->u.diadic.right = right;
+    cond->u.label.x4->u.diadic.left = typconLeft;
+    typconRight->u.monadic = cond->u.label.x4->u.diadic.right;
+    cond->u.label.x4->u.diadic.right = typconRight;
+
+    return count;
+};
+
+static int ReducePattern1(IRONode *startnode, IRONode *endnode) {
+    ReduceInfo *infos;
+    ReduceInfo *info;
+    int changed = 0;
+    int count;
+    IRONode *fnode;
+    int i;
+    int j;
+    CInt64 val;
+
+    if (startnode == endnode)
+        return 0;
+
+    count = 0;
+    for (fnode = startnode; fnode != endnode; fnode = fnode->nextnode)
+        count++;
+
+    infos = oalloc(sizeof(ReduceInfo) * ++count);
+
+    fnode = startnode;
+    for (i = 0; i < count; i++) {
+        infos[i].x0 = 0;
+        infos[i].x4 = 0;
+        infos[i].fnode = fnode;
+        infos[i].next = NULL;
+        infos[i].x8 = VEquConst(fnode->last->u.label.x4);
+        if (infos[i].x8) {
+            infos[i].val = fnode->last->u.label.x4->u.diadic.right->u.node->data.intval;
+            infos[i].x4 = 1;
+        }
+        fnode = fnode->nextnode;
+    }
+
+    for (j = 0; j < count; j++) {
+        if (infos[j].x4 == 1 && infos[j].x8) {
+            infos[j].x4 = -1;
+            info = &infos[j];
+            for (i = j + 1; i < count; i++) {
+                if (infos[j].x8 == infos[i].x8) {
+                    info->next = &infos[i];
+                    info = &infos[i];
+                    infos[i].x4 = 0;
+                }
+            }
+        }
+    }
+
+    for (j = 0; j < count; j++) {
+        if (infos[j].x4 == -1) {
+            for (info = &infos[j]; info; info = info->next) {
+                if (info->x0 == 0) {
+                    info->x0 = 2;
+                    val = info->val;
+                    if (MarkPattern1(&infos[j], info->next, &val)) {
+                        changed = 1;
+                        DoReducible1(&infos[j], val);
+                    } else {
+                        info->x0 = -1;
+                    }
+                }
+            }
+        }
+    }
+
+    return changed;
+}
+
+static int ReduceConsecutiveIf(IRONode *startnode, IRONode *endnode) {
+    IRONode *node31;
+    IRONode *node30;
+    int changed = 0;
+
+    while (startnode != endnode) {
+        if (checkStruct(startnode, startnode))
+            break;
+        startnode = startnode->nextnode;
+    }
+
+    node31 = startnode;
+    if (startnode != endnode) {
+        node30 = startnode;
+        node31 = startnode->nextnode;
+        while (node31 != endnode) {
+            if (checkStruct(startnode, node31)) {
+                node30 = node31;
+                node31 = node31->nextnode;
+            } else {
+                node31 = node30;
+                break;
+            }
+        }
+
+        if (node31 == endnode && !checkStruct(startnode, node31))
+            node31 = node30;
+
+        if (startnode != node31 && ReducePattern1(startnode, node31))
+            changed = 1;
+
+        if (node31 != endnode)
+            node31 = node31->nextnode;
+    }
+
+    if (node31 != endnode && ReduceConsecutiveIf(node31, endnode))
+        changed = 1;
+
+    return changed;
+}
+
+int IRO_SimplifyConditionals(void) {
+    IRONode *fnode;
+    IRONode *start;
+    IRONode *end;
+    int changed = 0;
+
+    for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
+        if (fnode->last->type == IROLinearIf) {
+            start = end = fnode;
+            while (fnode->nextnode && fnode->nextnode->last->type == IROLinearIf) {
+                end = fnode = fnode->nextnode;
+            }
+            if (start != end && ReduceConsecutiveIf(start, end))
+                changed = 1;
+        }
+    }
+
+    if (changed) {
+        IRO_ComputeSuccPred();
+        IRO_ComputeDom();
+    }
+    IRO_CheckForUserBreak();
+    return changed;
+}
+
+Boolean IRO_EvaluateDefinitePointers(Object *func) {
+    IROLinear *nd;
+    Boolean result; // r29
+    Boolean changed; // r28
+    Boolean changed2; // r26
+    IROLinear *nd2; // r25
+    IROListNode *scan; // r25
+    IROListNode *list;
+
+    if (!copts.opt_pointer_analysis)
+        return 0;
+
+    result = 0;
+
+    do {
+        changed = 0;
+
+        for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+            if (
+                nd->type == IROLinearOp1Arg &&
+                nd->nodetype == EINDIRECT &&
+                !(nd->flags & IROLF_Assigned) &&
+                nd->pointsToFunction &&
+                !IRO_HasSideEffect(nd) &&
+                PointerAnalysis_IsLinearNodePointerExprDefinite(func, nd)
+                )
+            {
+                list = NULL;
+                PointerAnalysis_LookupLinearNodePointerExpr(func, nd, &list);
+                if (list) {
+                    if (list->list.head && list->list.tail && !list->nextList) {
+                        changed2 = IRO_LocateFather_Cut_And_Paste(nd, list->list.tail) != NULL;
+                        if (changed2) {
+                            IRO_PasteAfter(list->list.head, list->list.tail, nd);
+                            for (nd2 = list->list.head; nd2 != list->list.tail->next; nd2 = nd2->next) {
+                                if (nd2->type == IROLinearOperand && nd2->u.node->type == EOBJREF) {
+                                    if (nd2->u.node->data.objref->datatype == DDATA || nd2->u.node->data.objref->datatype == DLOCAL)
+                                        IRO_FindVar(nd2->u.node->data.objref, 1, 1);
+                                    else
+                                        nd2->u.node->data.objref->varptr = NULL;
+                                }
+                            }
+                        }
+                        changed |= changed2;
+                    }
+
+                    while (list) {
+                        scan = list->nextList;
+                        IRO_free(list);
+                        list = scan;
+                    }
+                }
+            }
+        }
+
+        result |= changed;
+        IRO_CheckForUserBreak();
+    } while (changed);
+
+    return result;
+}
diff --git a/compiler_and_linker/unsorted/IroFlowgraph.c b/compiler_and_linker/unsorted/IroFlowgraph.c
index f9a18fd..5c9c840 100644
--- a/compiler_and_linker/unsorted/IroFlowgraph.c
+++ b/compiler_and_linker/unsorted/IroFlowgraph.c
@@ -331,5 +331,109 @@ IRONode *IRO_NewFlowGraphNode(void) {
 }
 
 IRONode *IRO_MergeFlowGraphNodes(IRONode *a, IRONode *b) {
-    // TODO
+    IRONode *succ;
+    Boolean found;
+    UInt32 i;
+    UInt32 j;
+    UInt32 k;
+
+    if (a->nextnode == b && a->last && b->first && a->last->next == b->first) {
+        if (b->first->type == IROLinearLabel)
+            IRO_NopOut(b->first);
+
+        a->nextnode = b->nextnode;
+        a->last = b->last;
+
+        for (i = 0; i < a->numsucc; i++) {
+            if (b->index == a->succ[i]) {
+                for (j = i; j < a->numsucc; j++) {
+                    if ((j + 1) < a->numsucc)
+                        a->succ[j] = a->succ[j + 1];
+                    else
+                        a->succ[j] = 0;
+                }
+                a->numsucc--;
+                break;
+            }
+        }
+
+        for (i = 0; i < b->numsucc; i++) {
+            succ = IRO_NodeTable[b->succ[i]];
+            for (j = 0; j < a->numsucc; j++) {
+                if (b->succ[i] == a->succ[j])
+                    break;
+            }
+
+            if (j == a->numsucc) {
+                AddSucc(a, IRO_NodeTable[b->succ[i]]);
+                succ->numpred--;
+            }
+
+            found = 0;
+            for (j = 0; j < succ->numpred; j++) {
+                if (a->index == succ->pred[j]) {
+                    found = 1;
+                    break;
+                }
+            }
+
+            for (j = 0; j < succ->numpred; j++) {
+                if (b->index == succ->pred[j]) {
+                    if (!found) {
+                        succ->pred[j] = a->index;
+                    } else {
+                        for (k = j; k < succ->numpred; k++) {
+                            if ((k + 1) < succ->numpred)
+                                succ->pred[k] = succ->pred[k + 1];
+                            else
+                                succ->pred[k] = 0;
+                        }
+                        succ->numpred--;
+                    }
+                    break;
+                }
+            }
+        }
+
+        b->numsucc = b->numpred = 0;
+        b->first = b->last = NULL;
+        b->nextnode = NULL;
+        b->x36 = 0;
+        b->x37 = 0;
+        b->mustreach = 0;
+        b->x39 = 0;
+        b->loopdepth = 0;
+
+        if (IRO_LastNode == b)
+            IRO_LastNode = a;
+
+        if (IRO_FirstExpr && IRO_LastExpr) {
+            IROExpr *expr;
+            for (expr = IRO_FirstExpr; expr && expr != IRO_LastExpr->next; expr = expr->next) {
+                if (expr->node == b)
+                    expr->node = a;
+            }
+        }
+
+        if (IRO_FirstAssign && IRO_LastAssign) {
+            IROAssign *assign;
+            for (assign = IRO_FirstAssign; assign && assign != IRO_LastAssign->next; assign = assign->next) {
+                if (assign->node == b)
+                    assign->node = a;
+            }
+        }
+
+        if (IRO_FirstVarUse && IRO_LastVarUse) {
+            IROUse *use;
+            for (use = IRO_FirstVarUse; use && use != IRO_LastVarUse->globalnext; use = use->globalnext) {
+                if (use->node == b)
+                    use->node = a;
+            }
+        }
+
+        IRO_NodeTable[b->index] = NULL;
+        return a;
+    }
+
+    return NULL;
 }
diff --git a/compiler_and_linker/unsorted/IroLoop.c b/compiler_and_linker/unsorted/IroLoop.c
index 01391bd..8a7f4fe 100644
--- a/compiler_and_linker/unsorted/IroLoop.c
+++ b/compiler_and_linker/unsorted/IroLoop.c
@@ -1902,7 +1902,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
             if (IS_LINEAR_DIADIC_2(loop->nd18, ELESS, ELESSEQU)) {
                 if (nd21->nodetype == EADDASS) {
                     if (scanind->addConst == 1)
-                        loop->flags |= LoopFlags_100;
+                        loop->flags |= LP_LOOP_STEP_ISADD;
                     if (scanind->addConst > 0)
                         loop->flags |= LP_LOOP_STEP_ISPOS;
                 } else if (nd21->nodetype == EASS &&
@@ -1910,7 +1910,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
                     IRO_IsIntConstant(tmp18 = nd21->u.diadic.right->u.diadic.right) &&
                     CTool_EndianReadWord32(&tmp18->u.node->data.intval.hi) == 0) {
                     if (CInt64_GetULong(&tmp18->u.node->data.intval) == 1)
-                        loop->flags |= LoopFlags_100;
+                        loop->flags |= LP_LOOP_STEP_ISADD;
                     if (CInt64_GetULong(&tmp18->u.node->data.intval) > 0)
                         loop->flags |= LP_LOOP_STEP_ISPOS;
                 }
@@ -1918,7 +1918,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
         } else if (nd21->type == IROLinearOp1Arg) {
             if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC) {
                 if (scanind->addConst == 1)
-                    loop->flags |= LoopFlags_100;
+                    loop->flags |= LP_LOOP_STEP_ISADD;
                 if (scanind->addConst > 0)
                     loop->flags |= LP_LOOP_STEP_ISPOS;
             }
@@ -1997,7 +1997,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
                         for (scanind = FirstInd; scanind; scanind = scanind->next) {
                             if (scanind->var->object == obj) {
                                 IRO_Dump("Induction has DIV: %s\n", obj->name->name);
-                                scanind->flags |= LoopInd_2;
+                                scanind->flags |= LoopInd_HasDiv;
                             }
                         }
                     }
@@ -2008,7 +2008,7 @@ IROLoop *ExtractLoopInfo(IRONode *fnode) {
                         for (scanind = FirstInd; scanind && obj; scanind = scanind->next) {
                             if (scanind->var->object == obj) {
                                 IRO_Dump("Induction has MOD: %s\n", obj->name->name);
-                                scanind->flags |= LoopInd_1;
+                                scanind->flags |= LoopInd_HasMod;
                             }
                         }
                     }
diff --git a/compiler_and_linker/unsorted/IroPointerAnalysis.c b/compiler_and_linker/unsorted/IroPointerAnalysis.c
index a47d544..0fb2498 100644
--- a/compiler_and_linker/unsorted/IroPointerAnalysis.c
+++ b/compiler_and_linker/unsorted/IroPointerAnalysis.c
@@ -43,9 +43,8 @@ static Boolean LocationIsVolatile(LocationSet *loc, Object *proc) {
     Boolean result;
     Type *rtype;
 
-#line 932
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(932, loc != NULL);
+    IRO_ASSERT(933, proc != NULL);
 
     result = 0;
 
@@ -107,9 +106,8 @@ static Object *GetLocalObject(PALocalVar *local, Object *proc, Boolean flag) {
     Object *obj;
     char *name;
 
-#line 999
-    IRO_ASSERT(local != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(999, local != NULL);
+    IRO_ASSERT(1000, proc != NULL);
 
     obj = PALocalVar_Get0_sub_4847E0(local);
     name = PALocalVar_Get4_sub_4847D0(local);
@@ -131,8 +129,7 @@ static Object *GetLocalObject(PALocalVar *local, Object *proc, Boolean flag) {
 }
 
 static Boolean ObjectIsAnExtendedParamCandidate(Object *obj) {
-#line 1042
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(1042, obj != NULL);
 
     return Inline_IsObjectData(obj) ||
         obj->datatype == DABSOLUTE ||
@@ -142,8 +139,7 @@ static Boolean ObjectIsAnExtendedParamCandidate(Object *obj) {
 }
 
 static Boolean ObjectIsAFunction(Object *obj) {
-#line 1054
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(1054, obj != NULL);
 
     return obj->datatype == DFUNC ||
            obj->datatype == DVFUNC ||
@@ -157,18 +153,16 @@ static Boolean LocationSetRepresentsSingleLocation(LocationSet *ls, Object *proc
     ExtendedParam *ep;
     ObjectSet *objSet;
 
-#line 1073
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(proc == NULL || proc != NULL);
-    IRO_ASSERT(pointsToFunc == NULL || pointsToFunc != NULL);
+    IRO_ASSERT(1073, ls != NULL);
+    IRO_ASSERT(1074, proc == NULL || proc != NULL);
+    IRO_ASSERT(1075, pointsToFunc == NULL || pointsToFunc != NULL);
 
     result = 1;
     if (LocationSet_IsUnknown(ls) || LocationSet_stride(ls)) {
         result = 0;
     } else {
         mb = LocationSet_block(ls);
-#line 1084
-        IRO_ASSERT(mb != NULL);
+        IRO_ASSERT(1084, mb != NULL);
 
         kind = PAMemoryBlock_kind(mb);
         if (kind == PAMEMORYBLOCKKIND_HEAPBLOCK) {
@@ -217,10 +211,9 @@ static void EvalExprAction(LocationSet *ls, void *refcon) {
     UInt32 stride;
     PAMemoryBlock *mb;
 
-#line 1151
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(1151, ls != NULL);
+    IRO_ASSERT(1152, !LocationSet_IsUnknown(ls));
+    IRO_ASSERT(1153, refcon != NULL);
 
     value = *((CInt64 *) refcon);
     stride = LocationSet_stride(ls);
@@ -247,10 +240,9 @@ static void EvalExprAction(LocationSet *ls, void *refcon) {
 static void EvalExprAction2(LocationSet *ls, void *refcon) {
     UInt32 value;
 
-#line 1188
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(1188, ls != NULL);
+    IRO_ASSERT(1189, !LocationSet_IsUnknown(ls));
+    IRO_ASSERT(1190, refcon != NULL);
 
     value = CInt64_GetULong((CInt64 *) refcon);
     if (value) {
@@ -279,9 +271,8 @@ typedef struct EvalExprAction3Params {
 static void EvalExprAction3(LocationSet *ls, void *refcon) {
     EvalExprAction3Params *params;
 
-#line 1219
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(1219, ls != NULL);
+    IRO_ASSERT(1220, refcon != NULL);
 
     params = refcon;
 
@@ -302,9 +293,8 @@ static void EvalExprAction4(LocationSet *ls, void *refcon) {
     Type *type;
     PAMemoryBlock *mb;
 
-#line 1235
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(1235, ls != NULL);
+    IRO_ASSERT(1236, refcon != NULL);
 
     type = refcon;
 
@@ -340,12 +330,11 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
     EvalExprAction3Params params;
     IROLinear *originalInt;
 
-#line 1284
-    IRO_ASSERT(set == NULL || set != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(Int != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(1284, set == NULL || set != NULL);
+    IRO_ASSERT(1285, proc != NULL);
+    IRO_ASSERT(1286, Int != NULL);
+    IRO_ASSERT(1287, map == NULL || map != NULL);
+    IRO_ASSERT(1288, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
 
     result = 0;
     lss = LocationSetSet_New();
@@ -355,16 +344,14 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
     while (Int && Int->type == IROLinearOp1Arg && Int->nodetype == ETYPCON)
         Int = Int->u.monadic;
 
-#line 1302
-    IRO_ASSERT(Int != NULL);
+    IRO_ASSERT(1302, Int != NULL);
 
     if (IRO_IsAssignment(Int)) {
         if (Int->type == IROLinearOp1Arg)
             indirect = Int->u.monadic;
         else
             indirect = Int->u.diadic.left;
-#line 1310
-        IRO_ASSERT(indirect->type == IROLinearOp1Arg && indirect->nodetype == EINDIRECT);
+        IRO_ASSERT(1310, indirect->type == IROLinearOp1Arg && indirect->nodetype == EINDIRECT);
 
         lss2 = LocationSetSet_New();
         LocationSetSet_Init(lss2);
@@ -387,8 +374,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
         LocationSetSet_Term(lss2);
         LocationSetSet_Delete(lss2);
     } else if (Int->type == IROLinearFunccall) {
-#line 1338
-        IRO_ASSERT(Int->u.funccall.returnedLocs != NULL);
+        IRO_ASSERT(1338, Int->u.funccall.returnedLocs != NULL);
         LocationSetSet_AddSet(lss, Int->u.funccall.returnedLocs);
     } else if (Int->type == IROLinearOp1Arg && Int->nodetype == EINDIRECT) {
         lss2 = LocationSetSet_New();
@@ -425,12 +411,10 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
             flag2 = 0;
             if (addr->numObjRefs == 1) {
                 Object *obj;
-#line 1383
-                IRO_ASSERT(addr->objRefs->element->type == IROLinearOperand);
-                IRO_ASSERT(addr->objRefs->element->u.node->type == EOBJREF);
+                IRO_ASSERT(1383, addr->objRefs->element->type == IROLinearOperand);
+                IRO_ASSERT(1384, addr->objRefs->element->u.node->type == EOBJREF);
                 obj = ((IROLinear *) addr->objRefs->element)->u.node->data.objref;
-#line 1387
-                IRO_ASSERT(obj != NULL);
+                IRO_ASSERT(1387, obj != NULL);
                 result |= EvalExpr(lss, proc, addr->objRefs->element, stackPtr, map, ptf);
                 flag2 = 1;
             }
@@ -536,8 +520,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
                     addend = list->element;
 
                     if (addend) {
-#line 1536
-                        IRO_ASSERT(IRO_IsIntConstant(addend));
+                        IRO_ASSERT(1536, IRO_IsIntConstant(addend));
 
                         value = CInt64_Add(value, addend->u.node->data.intval);
                     }
@@ -584,8 +567,7 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
             thing = Int->u.node;
         } else if (Int->u.node->type == EOBJREF) {
             obj = Int->u.node->data.objref;
-#line 1597
-            IRO_ASSERT(obj != NULL);
+            IRO_ASSERT(1597, obj != NULL);
             if (ObjectIsAnExtendedParamCandidate(obj)) {
                 kind = PAMEMORYBLOCKKIND_EXTENDEDPARAM;
                 thing = CreateExtendedParam(stackPtr, map, obj, &result);
@@ -619,12 +601,10 @@ static Boolean EvalExpr(LocationSetSet *set, Object *proc, IROLinear *Int, Stack
         LocationSetSet_Init(lss2);
         result |= EvalExpr(lss2, proc, Int->u.monadic, stackPtr, map, ptf);
 
-        if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2))) {
+        if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2)))
             LocationSetSet_AddUnknown(lss, NULL, NULL, ls);
-        } else {
-#line 1643
-            CError_FATAL();
-        }
+        else
+            CError_FATAL(1643);
 
         LocationSetSet_Term(lss2);
         LocationSetSet_Delete(lss2);
@@ -706,11 +686,11 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
     EvalExprAction3Params params;
     ENode *originalInt;
 
-    IRO_ASSERT(set == NULL || set != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(Int != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(0, set == NULL || set != NULL);
+    IRO_ASSERT(0, proc != NULL);
+    IRO_ASSERT(0, Int != NULL);
+    IRO_ASSERT(0, map == NULL || map != NULL);
+    IRO_ASSERT(0, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
 
     result = 0;
     lss = LocationSetSet_New();
@@ -720,14 +700,14 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
     while (Int && Int->type == ETYPCON)
         Int = Int->data.monadic;
 
-    IRO_ASSERT(Int != NULL);
+    IRO_ASSERT(0, Int != NULL);
 
     if (IRO_IsAssignOp[Int->type]) {
         if (Int->type == EPOSTINC || Int->type == EPOSTDEC || Int->type == EPREINC || Int->type == EPREDEC)
             indirect = Int->data.monadic;
         else
             indirect = Int->data.diadic.left;
-        IRO_ASSERT(indirect->type == EINDIRECT);
+        IRO_ASSERT(0, indirect->type == EINDIRECT);
 
         lss2 = LocationSetSet_New();
         LocationSetSet_Init(lss2);
@@ -787,7 +767,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
                 // IRO_ASSERT(addr->objRefs->element->type == IROLinearOperand);
                 // IRO_ASSERT(addr->objRefs->element->u.node->type == EOBJREF);
                 obj = ((ENode *) addr->objRefs->element)->data.objref;
-                IRO_ASSERT(obj != NULL);
+                IRO_ASSERT(0, obj != NULL);
                 result |= EvalENodeExpr(lss, proc, addr->objRefs->element, stackPtr, map, ptf);
                 flag2 = 1;
             }
@@ -896,7 +876,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
                     addend = list->element;
 
                     if (addend) {
-                        IRO_ASSERT(addend->type == EINTCONST);
+                        IRO_ASSERT(0, addend->type == EINTCONST);
 
                         value = CInt64_Add(value, addend->data.intval);
                     }
@@ -943,7 +923,7 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
             thing = Int;
         } else if (Int->type == EOBJREF) {
             obj = Int->data.objref;
-            IRO_ASSERT(obj != NULL);
+            IRO_ASSERT(0, obj != NULL);
             if (ObjectIsAnExtendedParamCandidate(obj)) {
                 kind = PAMEMORYBLOCKKIND_EXTENDEDPARAM;
                 thing = CreateExtendedParam(stackPtr, map, obj, &result);
@@ -977,12 +957,10 @@ static Boolean EvalENodeExpr(LocationSetSet *set, Object *proc, ENode *Int, Stac
         LocationSetSet_Init(lss2);
         result |= EvalENodeExpr(lss2, proc, Int->data.monadic, stackPtr, map, ptf);
 
-        if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2))) {
+        if (LocationSetSet_Count(lss2) == 1 && (ls = LocationSetSet_FindFirst(lss2)))
             LocationSetSet_AddUnknown(lss, NULL, NULL, ls);
-        } else {
-#line 2146
-            CError_FATAL();
-        }
+        else
+            CError_FATAL(2146);
 
         LocationSetSet_Term(lss2);
         LocationSetSet_Delete(lss2);
@@ -1064,9 +1042,8 @@ static Boolean EvalVariable(LocationSetSet *set, Object *proc, VarRecord *var, P
 }
 
 static void StoreReturnedLocationsAction(LocationSet *loc, void *refcon) {
-#line 2275
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2275, loc != NULL);
+    IRO_ASSERT(2276, refcon != NULL);
 
     if (!LocationSet_IsUnknown(loc)) {
         if (PAMemoryBlock_kind(LocationSet_block(loc)) == PAMEMORYBLOCKKIND_HEAPBLOCK) {
@@ -1095,11 +1072,10 @@ static void StoreReturnedLocations(IROLinear *nd, PartialTransferFunction *ptf,
     LocationSet *retLoc;
     LocationSetSet *retLocs;
 
-#line 2307
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(nd->type == IROLinearFunccall);
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(map != NULL);
+    IRO_ASSERT(2307, nd != NULL);
+    IRO_ASSERT(2308, nd->type == IROLinearFunccall);
+    IRO_ASSERT(2309, ptf != NULL);
+    IRO_ASSERT(2310, map != NULL);
 
     retLoc = PartialTransferFunction_returnLocation(ptf);
     retLocs = nd->u.funccall.returnedLocs;
@@ -1133,19 +1109,17 @@ static void FillInAppropriateMappingsWithExtParamAction(Object *obj, void *refco
     EPParams *params;
     ParamMapping *mapping;
 
-#line 2352
-    IRO_ASSERT(obj != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2352, obj != NULL);
+    IRO_ASSERT(2353, refcon != NULL);
 
     params = refcon;
 
-#line 2357
-    IRO_ASSERT(params->map != NULL);
-    IRO_ASSERT(params->ep != NULL);
-    IRO_ASSERT(params->proc == NULL || params->proc != NULL);
-    IRO_ASSERT(params->proc != &stUnknown);
-    IRO_ASSERT(params->var == NULL || params->var != NULL);
-    IRO_ASSERT(params->var != &stUnknown);
+    IRO_ASSERT(2357, params->map != NULL);
+    IRO_ASSERT(2358, params->ep != NULL);
+    IRO_ASSERT(2359, params->proc == NULL || params->proc != NULL);
+    IRO_ASSERT(2360, params->proc != &stUnknown);
+    IRO_ASSERT(2361, params->var == NULL || params->var != NULL);
+    IRO_ASSERT(2362, params->var != &stUnknown);
 
     mapping = ParamMappingFunction_FindMappingByFormal(params->map, obj);
     if (!mapping) {
@@ -1172,13 +1146,12 @@ static Boolean FillInAppropriateMappingsWithExtParam(ParamMappingFunction *map,
     EPParams params;
     ObjectSet *objSet;
 
-#line 2398
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(var == NULL || var != NULL);
-    IRO_ASSERT(var != &stUnknown);
-    IRO_ASSERT(ep != NULL);
-    IRO_ASSERT(proc == NULL || proc != NULL);
-    IRO_ASSERT(proc != &stUnknown);
+    IRO_ASSERT(2398, map != NULL);
+    IRO_ASSERT(2399, var == NULL || var != NULL);
+    IRO_ASSERT(2400, var != &stUnknown);
+    IRO_ASSERT(2401, ep != NULL);
+    IRO_ASSERT(2402, proc == NULL || proc != NULL);
+    IRO_ASSERT(2403, proc != &stUnknown);
 
     memset(&params, 0, sizeof(params));
     params.map = map;
@@ -1205,24 +1178,20 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
     PAMemoryBlockKind kind;
     Object *obj;
 
-#line 2448
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
-    IRO_ASSERT(locs != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(2448, loc != NULL);
+    IRO_ASSERT(2449, !LocationSet_IsUnknown(loc));
+    IRO_ASSERT(2450, locs != NULL);
+    IRO_ASSERT(2451, proc != NULL);
+    IRO_ASSERT(2452, map != NULL);
+    IRO_ASSERT(2453, ptf != NULL);
 
     initial = PartialTransferFunction_initialPointsToFn(ptf);
-#line 2456
-    IRO_ASSERT(initial != NULL);
+    IRO_ASSERT(2456, initial != NULL);
 
-#line 2458
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(2458, !LocationSet_IsUnknown(loc));
 
     block = LocationSet_block(loc);
-#line 2460
-    IRO_ASSERT(block != NULL);
+    IRO_ASSERT(2460, block != NULL);
 
     kind = PAMemoryBlock_kind(block);
 
@@ -1230,8 +1199,7 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
         PALocalVar *local;
 
         local = PAMemoryBlock_thing(block);
-#line 2466
-        IRO_ASSERT(local != NULL);
+        IRO_ASSERT(2466, local != NULL);
 
         obj = GetLocalObject(local, proc, 1);
         if (obj && ObjectIsAFunctionArgument(proc, obj)) {
@@ -1255,16 +1223,14 @@ static void MatchPTFHelper(LocationSet *loc, LocationSetSet *locs, Object *proc,
         }
     } else if (kind == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
         void *ep = PAMemoryBlock_thing(block);
-#line 2489
-        IRO_ASSERT(ep != NULL);
+        IRO_ASSERT(2489, ep != NULL);
 
         obj = NULL;
         ObjectSet_ForEach(ExtendedParam_objectSet(ep), FindGlobalObjectAction, &obj);
         if (obj && obj != &stUnknown)
             FillInAppropriateMappingsWithExtParam(map, obj, ep, proc);
     } else {
-#line 2500
-        CError_FATAL();
+        CError_FATAL(2500);
     }
 
     if (!PointsToFunction_FindByLookupCompatibleLocationSet(initial, loc)) {
@@ -1296,16 +1262,14 @@ static void MatchPTFAction1(PointsToEntry *tgtPTE, void *refcon) {
     PAMemoryBlock *block;
     PAMemoryBlockKind kind;
 
-#line 2525
-    IRO_ASSERT(tgtPTE != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2525, tgtPTE != NULL);
+    IRO_ASSERT(2526, refcon != NULL);
 
     params = refcon;
 
-#line 2530
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->ptfCopy != NULL);
-    IRO_ASSERT(params->mapCopy != NULL);
+    IRO_ASSERT(2530, params->proc != NULL);
+    IRO_ASSERT(2531, params->ptfCopy != NULL);
+    IRO_ASSERT(2532, params->mapCopy != NULL);
 
     if ((loc = PointsToEntry_loc(tgtPTE)) && (locs = PointsToEntry_locs(tgtPTE))) {
         if ((block = LocationSet_block(loc))) {
@@ -1313,8 +1277,7 @@ static void MatchPTFAction1(PointsToEntry *tgtPTE, void *refcon) {
             if (kind == PAMEMORYBLOCKKIND_LOCALVAR) {
                 MatchPTFHelper(loc, locs, params->proc, params->mapCopy, params->ptfCopy);
             } else if (kind != PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
-#line 2547
-                CError_FATAL();
+                CError_FATAL(2547);
             }
         }
     }
@@ -1327,16 +1290,14 @@ static void MatchPTFAction2(PointsToEntry *tgtPTE, void *refcon) {
     PAMemoryBlock *block;
     PAMemoryBlockKind kind;
 
-#line 2561
-    IRO_ASSERT(tgtPTE != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2561, tgtPTE != NULL);
+    IRO_ASSERT(2562, refcon != NULL);
 
     params = refcon;
 
-#line 2566
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->ptfCopy != NULL);
-    IRO_ASSERT(params->mapCopy != NULL);
+    IRO_ASSERT(2566, params->proc != NULL);
+    IRO_ASSERT(2567, params->ptfCopy != NULL);
+    IRO_ASSERT(2568, params->mapCopy != NULL);
 
     if ((loc = PointsToEntry_loc(tgtPTE)) && (locs = PointsToEntry_locs(tgtPTE))) {
         if ((block = LocationSet_block(loc))) {
@@ -1355,12 +1316,11 @@ static Boolean MatchPTF(PartialTransferFunction *tgtPTF, Object *proc, ParamMapp
     PointsToFunction *initial;
     MatchPTFActionParams params;
 
-#line 2593
-    IRO_ASSERT(tgtPTF != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(2593, tgtPTF != NULL);
+    IRO_ASSERT(2594, proc != NULL);
+    IRO_ASSERT(2595, map != NULL);
+    IRO_ASSERT(2596, nd != NULL);
+    IRO_ASSERT(2597, ptf != NULL);
 
     ptfCopy = PartialTransferFunction_New();
     PartialTransferFunction_Copy(ptfCopy, ptf);
@@ -1401,9 +1361,8 @@ static Boolean MatchPTF(PartialTransferFunction *tgtPTF, Object *proc, ParamMapp
 static void FindCallTargetsAction2(Object *obj, void *refcon) {
     ObjectSet *procList;
 
-#line 2650
-    IRO_ASSERT(obj != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2650, obj != NULL);
+    IRO_ASSERT(2651, refcon != NULL);
 
     procList = refcon;
 
@@ -1414,9 +1373,8 @@ static void FindCallTargetsAction2(Object *obj, void *refcon) {
 static void FindCallTargetsAction(LocationSet *ls, void *refcon) {
     ObjectSet *procList;
 
-#line 2669
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2669, ls != NULL);
+    IRO_ASSERT(2670, refcon != NULL);
 
     procList = refcon;
 
@@ -1437,13 +1395,12 @@ static int FindCallTargets(ObjectSet *procList, Object *proc, IROLinear *nd, Par
     int evalResult;
     int result;
 
-#line 2696
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(nd->type == IROLinearFunccall);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(2696, procList != NULL);
+    IRO_ASSERT(2697, proc != NULL);
+    IRO_ASSERT(2698, nd != NULL);
+    IRO_ASSERT(2699, nd->type == IROLinearFunccall);
+    IRO_ASSERT(2700, map != NULL);
+    IRO_ASSERT(2701, ptf != NULL);
 
     set = LocationSetSet_New();
     LocationSetSet_Init(set);
@@ -1460,14 +1417,13 @@ static int LookupParam(LocationSetSet *set, LocationSet *ls, Object *var, Stack
     Boolean result;
     ExtendedParam *ep;
 
-#line 2728
-    IRO_ASSERT(set == NULL || set != NULL);
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(var != NULL);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(ptf == NULL || ptf != NULL);
+    IRO_ASSERT(2728, set == NULL || set != NULL);
+    IRO_ASSERT(2729, ls != NULL);
+    IRO_ASSERT(2730, var != NULL);
+    IRO_ASSERT(2731, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(2732, proc != NULL);
+    IRO_ASSERT(2733, map == NULL || map != NULL);
+    IRO_ASSERT(2734, ptf == NULL || ptf != NULL);
 
     result = 0;
 
@@ -1475,8 +1431,7 @@ static int LookupParam(LocationSetSet *set, LocationSet *ls, Object *var, Stack
     if (!ep)
         ep = CreateExtendedParam(stackPtr, map, var, &result);
 
-#line 2741
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(2741, ep != NULL);
 
     if (ep) {
         PAMemoryBlock *block;
@@ -1547,13 +1502,12 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
     UInt32 savedStride;
     LocationSetSet *newSet;
 
-#line 2821
-    IRO_ASSERT(set == NULL || set != NULL);
-    IRO_ASSERT((ls != NULL && var == NULL) || (ls == NULL && var != NULL));
-    IRO_ASSERT(ls == NULL || !LocationSet_IsUnknown(ls));
-    IRO_ASSERT(var != &stUnknown);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
+    IRO_ASSERT(2821, set == NULL || set != NULL);
+    IRO_ASSERT(2822, (ls != NULL && var == NULL) || (ls == NULL && var != NULL));
+    IRO_ASSERT(2823, ls == NULL || !LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2824, var != &stUnknown);
+    IRO_ASSERT(2825, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(2826, map == NULL || map != NULL);
 
     result = 0;
     block = NULL;
@@ -1563,21 +1517,18 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
 
     if (ls) {
         block = LocationSet_block(ls);
-#line 2838
-        IRO_ASSERT(block != NULL);
-        IRO_ASSERT(PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+        IRO_ASSERT(2838, block != NULL);
+        IRO_ASSERT(2839, PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
 
         ep = PAMemoryBlock_thing(block);
-#line 2842
-        IRO_ASSERT(ep != NULL);
+        IRO_ASSERT(2842, ep != NULL);
 
         savedField = LocationSet_field(ls);
         savedStride = LocationSet_stride(ls);
         savedRtype = LocationSet_rtype(ls);
     }
 
-#line 2848
-    IRO_ASSERT(ep == NULL || ep != NULL);
+    IRO_ASSERT(2848, ep == NULL || ep != NULL);
 
     if (stackPtr && *stackPtr) {
         StackElement *element = Stack_Top(stackPtr);
@@ -1585,12 +1536,10 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
             map = StackElement_map(element);
     }
 
-#line 2859
-    IRO_ASSERT(map == NULL || map != NULL);
+    IRO_ASSERT(2859, map == NULL || map != NULL);
 
     if (ep) {
-#line 2863
-        IRO_ASSERT(var == NULL);
+        IRO_ASSERT(2863, var == NULL);
         ObjectSet_ForEach(ExtendedParam_objectSet(ep), FindGlobalObjectAction, &var);
         if (!var)
             var = ObjectSet_FindFirst(ExtendedParam_objectSet(ep));
@@ -1598,8 +1547,7 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
             var = &stUnknown;
     }
 
-#line 2870
-    IRO_ASSERT(var != NULL);
+    IRO_ASSERT(2870, var != NULL);
 
     if (map && var != &stUnknown) {
         if (flag)
@@ -1610,17 +1558,15 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
     newSet = LocationSetSet_New();
     LocationSetSet_Init(newSet);
 
-#line 2884
-    IRO_ASSERT(mapping == NULL || mapping != NULL);
+    IRO_ASSERT(2884, mapping == NULL || mapping != NULL);
 
     if (mapping)
         nd = ParamMapping_actual(mapping);
 
     if (!nd) {
         if (!ls) {
-#line 2893
-            IRO_ASSERT(var != NULL);
-            IRO_ASSERT(ep == NULL);
+            IRO_ASSERT(2893, var != NULL);
+            IRO_ASSERT(2894, ep == NULL);
 
             if (var != &stUnknown) {
                 ep = CreateExtendedParam(stackPtr, NULL, var, &result);
@@ -1643,8 +1589,7 @@ static Boolean GetActualLocsOfExtendedParam(LocationSetSet *set, LocationSet *ls
             savedRtype = NULL;
         }
 
-#line 2925
-        IRO_ASSERT(block != NULL);
+        IRO_ASSERT(2925, block != NULL);
 
         if (block == LocationSet_block(stUnknownLs)) {
             LocationSetSet_AddUnknown(newSet, savedRtype, NULL, NULL);
@@ -1718,17 +1663,15 @@ typedef struct ExpandLocationSetSetActionParams {
 static void ExpandLocationSetSetToActualsAction(LocationSet *ls, void *refcon) {
     ExpandLocationSetSetActionParams *params;
 
-#line 3021
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3021, ls != NULL);
+    IRO_ASSERT(3022, refcon != NULL);
 
     params = refcon;
 
-#line 3026
-    IRO_ASSERT(params->toBeRemoved != NULL);
-    IRO_ASSERT(params->toBeAdded != NULL);
-    IRO_ASSERT(params->stackPtr == NULL || *params->stackPtr == NULL || *params->stackPtr != NULL);
-    IRO_ASSERT(params->map == NULL || params->map != NULL);
+    IRO_ASSERT(3026, params->toBeRemoved != NULL);
+    IRO_ASSERT(3027, params->toBeAdded != NULL);
+    IRO_ASSERT(3028, params->stackPtr == NULL || *params->stackPtr == NULL || *params->stackPtr != NULL);
+    IRO_ASSERT(3029, params->map == NULL || params->map != NULL);
 
     if (!LocationSet_IsUnknown(ls)) {
         PAMemoryBlock *block = LocationSet_block(ls);
@@ -1753,10 +1696,9 @@ static int ExpandLocationSetSetToActuals(Stack **stackPtr, ParamMappingFunction
     ExpandLocationSetSetActionParams params;
     Boolean result;
 
-#line 3063
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(thingsPointedTo != NULL);
+    IRO_ASSERT(3063, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(3064, map == NULL || map != NULL);
+    IRO_ASSERT(3065, thingsPointedTo != NULL);
 
     toBeRemoved = LocationSetSet_New();
     LocationSetSet_Init(toBeRemoved);
@@ -1791,15 +1733,13 @@ static void EvaluatePartialAbsolute(LocationSetSet *set, LocationSetSet *thingsP
     Type *absLocRtype;
     PAMemoryBlock *block;
 
-#line 3108
-    IRO_ASSERT(set != NULL);
-    IRO_ASSERT(thingsPointedTo != NULL);
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(indRtype != NULL);
+    IRO_ASSERT(3108, set != NULL);
+    IRO_ASSERT(3109, thingsPointedTo != NULL);
+    IRO_ASSERT(3110, dst != NULL);
+    IRO_ASSERT(3111, indRtype != NULL);
 
     absLoc = LocationSetSet_FindFirst(thingsPointedTo);
-#line 3114
-    IRO_ASSERT(absLoc != NULL);
+    IRO_ASSERT(3114, absLoc != NULL);
 
     if (!LocationSet_IsUnknown(absLoc))
         absLocRtype = LocationSet_rtype(absLoc);
@@ -1862,10 +1802,9 @@ static Boolean AddToInitialPointsToFunc(Boolean flag, PartialTransferFunction *p
     PointsToFunction *initial;
     PointsToEntry *pte;
 
-#line 3192
-    IRO_ASSERT(ptf == NULL || ptf != NULL);
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(set != NULL);
+    IRO_ASSERT(3192, ptf == NULL || ptf != NULL);
+    IRO_ASSERT(3193, dst != NULL);
+    IRO_ASSERT(3194, set != NULL);
 
     result = 0;
 
@@ -1874,8 +1813,7 @@ static Boolean AddToInitialPointsToFunc(Boolean flag, PartialTransferFunction *p
         if (!ls || LocationSet_rtype(ls)) {
             initial = PartialTransferFunction_initialPointsToFn(ptf);
             if (initial && !PointsToFunction_FindByLookupCompatibleLocationSet(initial, dst)) {
-#line 3208
-                IRO_ASSERT(dst != NULL);
+                IRO_ASSERT(3208, dst != NULL);
 
                 pte = PointsToEntry_New();
                 PointsToEntry_Init(pte, dst, set);
@@ -1899,15 +1837,14 @@ static Boolean Lookup(LocationSetSet *set, Stack **stackPtr, Object *proc, Param
     ObjectSet *objSet;
     Object *obj;
 
-#line 3245
-    IRO_ASSERT(set == NULL || set != NULL);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(proc == NULL || proc != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(ptf == NULL || ptf != NULL);
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(pointsToFunc == NULL || pointsToFunc != NULL);
-    IRO_ASSERT(indRtype == NULL || indRtype != NULL);
+    IRO_ASSERT(3245, set == NULL || set != NULL);
+    IRO_ASSERT(3246, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(3247, proc == NULL || proc != NULL);
+    IRO_ASSERT(3248, map == NULL || map != NULL);
+    IRO_ASSERT(3249, ptf == NULL || ptf != NULL);
+    IRO_ASSERT(3250, dst != NULL);
+    IRO_ASSERT(3251, pointsToFunc == NULL || pointsToFunc != NULL);
+    IRO_ASSERT(3252, indRtype == NULL || indRtype != NULL);
 
     result = 0;
 
@@ -2028,9 +1965,8 @@ static Boolean Lookup(LocationSetSet *set, Stack **stackPtr, Object *proc, Param
 }
 
 static Boolean InputsHaveNewPointerValues(PartialTransferFunction *tgtPTF, PartialTransferFunction *ptf) {
-#line 3393
-    IRO_ASSERT(tgtPTF != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(3393, tgtPTF != NULL);
+    IRO_ASSERT(3394, ptf != NULL);
 
     return 0;
 }
@@ -2055,14 +1991,13 @@ static void CreateExtendedParamAction(ParamMapping *mapping, void *refcon) {
     ExtendedParam *lastEP;
     uint32 lastValue;
 
-#line 3417
-    IRO_ASSERT(mapping != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3417, mapping != NULL);
+    IRO_ASSERT(3418, refcon != NULL);
 
     params = refcon;
 
-    IRO_ASSERT(params->last == NULL || params->last != NULL);
-    IRO_ASSERT(params->lowest == NULL || params->lowest != NULL);
+    IRO_ASSERT(3422, params->last == NULL || params->last != NULL);
+    IRO_ASSERT(3423, params->lowest == NULL || params->lowest != NULL);
 
     if ((ep = ParamMapping_extended(mapping))) {
         value = ExtendedParam_sub_489110(ep);
@@ -2093,11 +2028,10 @@ static ExtendedParam *FindMatchingExtendedParam(Stack **stackPtr, ParamMappingFu
     ExtendedParam *ep;
     ExtendedParam *lowestEP;
 
-#line 3473
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(lowest != NULL);
+    IRO_ASSERT(3473, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(3474, map == NULL || map != NULL);
+    IRO_ASSERT(3475, lss != NULL);
+    IRO_ASSERT(3476, lowest != NULL);
 
     ep = NULL;
     if ((lowestEP = ParamMapping_extended(lowest))) {
@@ -2134,10 +2068,9 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
     LocationSetSet *lss;
     CreateEPActionParams params;
 
-#line 3518
-    IRO_ASSERT(map == NULL || map != NULL);
-    IRO_ASSERT(stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
-    IRO_ASSERT(var != NULL);
+    IRO_ASSERT(3518, map == NULL || map != NULL);
+    IRO_ASSERT(3519, stackPtr == NULL || *stackPtr == NULL || *stackPtr != NULL);
+    IRO_ASSERT(3520, var != NULL);
 
     mapping = NULL;
     if (map)
@@ -2145,10 +2078,8 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
 
     ep = ExtendedParam_FindByObject(var);
     if (ep) {
-        if (mapping) {
-#line 3535
-            IRO_ASSERT(ep == ParamMapping_extended(mapping) || ParamMapping_extended(mapping) == NULL);
-        }
+        if (mapping)
+            IRO_ASSERT(3535, ep == ParamMapping_extended(mapping) || ParamMapping_extended(mapping) == NULL);
     } else if (map && !ObjectIsRestrictQualified(var)) {
         lss = LocationSetSet_New();
         LocationSetSet_Init(lss);
@@ -2181,26 +2112,23 @@ static ExtendedParam *CreateExtendedParam(Stack **stackPtr, ParamMappingFunction
     if (stExtParamSet)
         ExtParamSet_sub_487630(stExtParamSet, ep);
 
-#line 3583
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(3583, ep != NULL);
 
     return ep;
 }
 
 #ifdef IRO_DEBUG
 void __assertion_failed(char *expr, char *filename, int line) {
-#line 3605
-    CError_ASSERT(filename);
+    CError_ASSERT(3605, filename);
     CError_Internal(filename, line);
 }
 #endif
 
 static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map) {
-#line 3628
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(nd->type == IROLinearFunccall);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(map != NULL);
+    IRO_ASSERT(3628, nd != NULL);
+    IRO_ASSERT(3629, nd->type == IROLinearFunccall);
+    IRO_ASSERT(3630, proc != NULL);
+    IRO_ASSERT(3631, map != NULL);
 
     if (proc != &stUnknown) {
         int i;
@@ -2214,8 +2142,7 @@ static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map
             arg = &stUnknown;
 
         for (i = 0; i < nd->u.funccall.argCount; i++) {
-#line 3643
-            IRO_ASSERT(arg != NULL);
+            IRO_ASSERT(3643, arg != NULL);
 
             if (arg != &stUnknown) {
                 ParamMapping *mapping = ParamMapping_New();
@@ -2237,10 +2164,9 @@ static void RecordActuals(IROLinear *nd, Object *proc, ParamMappingFunction *map
 }
 
 static Boolean IsAddressableLocation(LocationSet *loc, Object *proc, IRONode *fnode, IROLinear *nd) {
-#line 3676
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(nd != NULL);
+    IRO_ASSERT(3676, loc != NULL);
+    IRO_ASSERT(3677, fnode != NULL);
+    IRO_ASSERT(3678, nd != NULL);
 
     if (!LocationSet_IsUnknown(loc)) {
         PAMemoryBlock *block;
@@ -2277,9 +2203,8 @@ static Boolean IsAddressableLocation(LocationSet *loc, Object *proc, IRONode *fn
 }
 
 static Boolean LocationSetsAlias(LocationSet *ls1, LocationSet *ls2) {
-#line 3719
-    IRO_ASSERT(ls1 != NULL);
-    IRO_ASSERT(ls2 != NULL);
+    IRO_ASSERT(3719, ls1 != NULL);
+    IRO_ASSERT(3720, ls2 != NULL);
 
     return
         (ls1 == ls2) ||
@@ -2319,9 +2244,8 @@ static void FindAliasingAction2(LocationSet *ls, void *refcon) {
 static void FindAliasingAction(LocationSet *ls, void *refcon) {
     FindAliasingParams *params;
 
-#line 3751
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3751, ls != NULL);
+    IRO_ASSERT(3752, refcon != NULL);
 
     params = refcon;
 
@@ -2351,24 +2275,21 @@ static void KillAllAddressableLocationsAction(PointsToEntry *pte, void *refcon)
     KillLocationParams *params;
     LocationSet *loc;
 
-#line 3779
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3779, pte != NULL);
+    IRO_ASSERT(3780, refcon != NULL);
 
     params = refcon;
 
-#line 3784
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->toBeKilled != NULL);
-    IRO_ASSERT(params->dst == NULL);
+    IRO_ASSERT(3784, params->proc != NULL);
+    IRO_ASSERT(3785, params->fnode != NULL);
+    IRO_ASSERT(3786, params->nd != NULL);
+    IRO_ASSERT(3787, params->ptf != NULL);
+    IRO_ASSERT(3788, params->toBeKilled != NULL);
+    IRO_ASSERT(3789, params->dst == NULL);
 
     loc = PointsToEntry_loc(pte);
-#line 3793
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(3793, loc != NULL);
+    IRO_ASSERT(3794, !LocationSet_IsUnknown(loc));
 
     if (IsAddressableLocation(loc, params->proc, params->fnode, params->nd))
         PointsToFunction_Add(params->toBeKilled, pte);
@@ -2378,26 +2299,23 @@ static void KillAllAliasingExtParamLocsAction(PointsToEntry *pte, void *refcon)
     KillLocationParams *params;
     LocationSet *loc;
 
-#line 3813
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3813, pte != NULL);
+    IRO_ASSERT(3814, refcon != NULL);
 
     params = refcon;
 
-#line 3818
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->toBeKilled != NULL);
-    IRO_ASSERT(params->dst != NULL);
-    IRO_ASSERT(LocationSet_block(params->dst) != NULL);
-    IRO_ASSERT(PAMemoryBlock_kind(LocationSet_block(params->dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+    IRO_ASSERT(3818, params->proc != NULL);
+    IRO_ASSERT(3819, params->fnode != NULL);
+    IRO_ASSERT(3820, params->nd != NULL);
+    IRO_ASSERT(3821, params->ptf != NULL);
+    IRO_ASSERT(3822, params->toBeKilled != NULL);
+    IRO_ASSERT(3823, params->dst != NULL);
+    IRO_ASSERT(3824, LocationSet_block(params->dst) != NULL);
+    IRO_ASSERT(3825, PAMemoryBlock_kind(LocationSet_block(params->dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
 
     loc = PointsToEntry_loc(pte);
-#line 3829
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(3829, loc != NULL);
+    IRO_ASSERT(3830, !LocationSet_IsUnknown(loc));
 
     if (loc != params->dst) {
         if (LocationSetsAlias(loc, params->dst)) {
@@ -2452,24 +2370,21 @@ static void KillLocationsAction(PointsToEntry *pte, void *refcon) {
     LocationSet *loc;
     LocationSetSet *lss;
 
-#line 3886
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3886, pte != NULL);
+    IRO_ASSERT(3887, refcon != NULL);
 
     params = refcon;
 
-#line 3891
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->toBeKilled != NULL);
-    IRO_ASSERT(params->dst == NULL);
+    IRO_ASSERT(3891, params->proc != NULL);
+    IRO_ASSERT(3892, params->fnode != NULL);
+    IRO_ASSERT(3893, params->nd != NULL);
+    IRO_ASSERT(3894, params->ptf != NULL);
+    IRO_ASSERT(3895, params->toBeKilled != NULL);
+    IRO_ASSERT(3896, params->dst == NULL);
 
     loc = PointsToEntry_loc(pte);
-#line 3900
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(3900, loc != NULL);
+    IRO_ASSERT(3901, !LocationSet_IsUnknown(loc));
 
     lss = LocationSetSet_New();
     LocationSetSet_Init(lss);
@@ -2488,11 +2403,10 @@ static Boolean KillAllAddressableLocations(Object *proc, IRONode *fnode, IROLine
     PointsToFunction *toBeKilled;
     KillLocationParams params;
 
-#line 3921
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode == NULL || fnode != NULL);
-    IRO_ASSERT(nd == NULL || nd != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(3921, proc != NULL);
+    IRO_ASSERT(3922, fnode == NULL || fnode != NULL);
+    IRO_ASSERT(3923, nd == NULL || nd != NULL);
+    IRO_ASSERT(3924, ptf != NULL);
 
     if (nd && nd->pointsToFunction)
         pointsToFunc = nd->pointsToFunction;
@@ -2538,12 +2452,11 @@ static void KillAllAliasingExtParamLocs(Object *proc, IRONode *fnode, IROLinear
     PointsToFunction *toBeKilled;
     KillLocationParams params;
 
-#line 3974
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode == NULL || fnode != NULL);
-    IRO_ASSERT(nd == NULL || nd != NULL);
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(dst != NULL);
+    IRO_ASSERT(3974, proc != NULL);
+    IRO_ASSERT(3975, fnode == NULL || fnode != NULL);
+    IRO_ASSERT(3976, nd == NULL || nd != NULL);
+    IRO_ASSERT(3977, ptf != NULL);
+    IRO_ASSERT(3978, dst != NULL);
 
     if (!LocationSet_IsUnknown(dst) && LocationSet_block(dst)) {
         if (PAMemoryBlock_kind(LocationSet_block(dst)) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
@@ -2585,13 +2498,12 @@ static Boolean Assign(PartialTransferFunction *ptf, LocationSet *dst, LocationSe
     LocationSet *bitfieldOf;
     LocationSetSet *lss;
 
-#line 4027
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(srcs != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(nd == NULL || nd != NULL);
-    IRO_ASSERT(fnode == NULL || fnode != NULL);
+    IRO_ASSERT(4027, ptf != NULL);
+    IRO_ASSERT(4028, dst != NULL);
+    IRO_ASSERT(4029, srcs != NULL);
+    IRO_ASSERT(4030, proc != NULL);
+    IRO_ASSERT(4031, nd == NULL || nd != NULL);
+    IRO_ASSERT(4032, fnode == NULL || fnode != NULL);
 
     if (nd) {
         if (!nd->pointsToFunction) {
@@ -2607,9 +2519,8 @@ static Boolean Assign(PartialTransferFunction *ptf, LocationSet *dst, LocationSe
     if (pte) {
         loc = PointsToEntry_loc(pte);
         locs = PointsToEntry_locs(pte);
-#line 4056
-        IRO_ASSERT(!LocationSet_IsUnknown(dst));
-        IRO_ASSERT(LocationSet_stride(dst) == 0 || LocationSet_stride(loc) != 0);
+        IRO_ASSERT(4056, !LocationSet_IsUnknown(dst));
+        IRO_ASSERT(4057, LocationSet_stride(dst) == 0 || LocationSet_stride(loc) != 0);
 
         result = !LocationSetSets_Equal(srcs, locs) || LocationSet_stride(dst) != LocationSet_stride(loc);
 
@@ -2665,18 +2576,16 @@ static void EvalMeetAction(PointsToEntry *pte, void *refcon) {
     LocationSetSet *set;
     UInt16 i;
 
-#line 4123
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(4123, pte != NULL);
+    IRO_ASSERT(4124, refcon != NULL);
 
     params = refcon;
 
-#line 4128
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->pred != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
+    IRO_ASSERT(4128, params->proc != NULL);
+    IRO_ASSERT(4129, params->fnode != NULL);
+    IRO_ASSERT(4130, params->pred != NULL);
+    IRO_ASSERT(4131, params->nd != NULL);
+    IRO_ASSERT(4132, params->ptf != NULL);
 
     loc = PointsToEntry_loc(pte);
 
@@ -2701,11 +2610,10 @@ static Boolean EvalMeet(Object *proc, IRONode *fnode, IROLinear *nd, PartialTran
     EvalMeetActionParams params;
     int i;
 
-#line 4163
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4163, proc != NULL);
+    IRO_ASSERT(4164, fnode != NULL);
+    IRO_ASSERT(4165, nd != NULL);
+    IRO_ASSERT(4166, ptf != NULL);
 
     pointsToFunc = PointsToFunction_New();
     if (nd->pointsToFunction)
@@ -2745,11 +2653,10 @@ static Boolean EvalMeet(Object *proc, IRONode *fnode, IROLinear *nd, PartialTran
 static PartialTransferFunction *AllocatePTF(Object *proc, IROLinear *nd, PartialTransferFunction *ptf) {
     PartialTransferFunction *newPTF;
 
-#line 4210
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(proc->u.func.ptfList != NULL);
-    IRO_ASSERT(nd == NULL || nd != NULL);
-    IRO_ASSERT(ptf == NULL || ptf != NULL);
+    IRO_ASSERT(4210, proc != NULL);
+    IRO_ASSERT(4211, proc->u.func.ptfList != NULL);
+    IRO_ASSERT(4212, nd == NULL || nd != NULL);
+    IRO_ASSERT(4213, ptf == NULL || ptf != NULL);
 
     newPTF = PartialTransferFunction_New();
     PartialTransferFunction_Init(newPTF, nd, ptf);
@@ -2758,8 +2665,7 @@ static PartialTransferFunction *AllocatePTF(Object *proc, IROLinear *nd, Partial
 }
 
 static Object *FindMainEntryPoint(Object *function) {
-#line 4229
-    IRO_ASSERT(function != NULL);
+    IRO_ASSERT(4229, function != NULL);
 
     return function;
 }
@@ -2776,8 +2682,7 @@ static ObjectList *FunctionArguments(Object *proc) {
     FuncArg *args;
     Boolean notFound;
 
-#line 4252
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(4252, proc != NULL);
 
     if (proc == stCurrentProc) {
         for (list = arguments; list; list = list->next) {
@@ -2866,21 +2771,17 @@ static ObjectList *FunctionArguments(Object *proc) {
 }
 
 static IRONode **FunctionNodeTable(Object *proc) {
-#line 4383
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(4383, proc != NULL);
 
-#line 4391
-    IRO_ASSERT(proc == stCurrentProc);
+    IRO_ASSERT(4391, proc == stCurrentProc);
 
     return IRO_NodeTable;
 }
 
 static IRONode *FunctionFirstNode(Object *proc) {
-#line 4401
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(4401, proc != NULL);
 
-#line 4409
-    IRO_ASSERT(proc == stCurrentProc);
+    IRO_ASSERT(4409, proc == stCurrentProc);
 
     return IRO_FirstNode;
 }
@@ -2914,18 +2815,16 @@ static void EvalCallAction(Object *proc, void *refcon) {
     Boolean flag;
     Boolean flag2;
 
-#line 4458
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(4458, proc != NULL);
+    IRO_ASSERT(4459, refcon != NULL);
 
     params = refcon;
 
-#line 4463
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->map == NULL || params->map != NULL);
+    IRO_ASSERT(4463, params->proc != NULL);
+    IRO_ASSERT(4464, params->fnode != NULL);
+    IRO_ASSERT(4465, params->nd != NULL);
+    IRO_ASSERT(4466, params->ptf != NULL);
+    IRO_ASSERT(4467, params->map == NULL || params->map != NULL);
 
     if (!params->x18) {
         pmf = ParamMappingFunction_New();
@@ -2945,8 +2844,7 @@ static void EvalCallAction(Object *proc, void *refcon) {
             StackElement_Term(element);
             StackElement_Delete(element);
 
-#line 4490
-            IRO_ASSERT(tgtPTF != NULL);
+            IRO_ASSERT(4490, tgtPTF != NULL);
 
             flag = 1;
 
@@ -2984,12 +2882,11 @@ static Boolean EvalCall(Object *proc, IRONode *fnode, IROLinear *nd, ParamMappin
     EvalCallActionParams params;
     ObjectSet *objSet;
 
-#line 4548
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4548, proc != NULL);
+    IRO_ASSERT(4549, fnode != NULL);
+    IRO_ASSERT(4550, nd != NULL);
+    IRO_ASSERT(4551, map != NULL);
+    IRO_ASSERT(4552, ptf != NULL);
 
     memset(&params, 0, sizeof(params));
     params.proc = proc;
@@ -3031,8 +2928,7 @@ static void AdjustTypesForVolatilityAction(LocationSet *ls, void *refcon) {
             qual = TYPE_MEMBER_POINTER(type)->qual;
             break;
         default:
-#line 4604
-            CError_FATAL();
+            CError_FATAL(4604);
     }
 
     if (!(qual & Q_VOLATILE)) {
@@ -3082,17 +2978,15 @@ static void EvalAssignAction2(LocationSet *ls, void *refcon) {
     Type *rtype;
     PAMemoryBlock *block;
 
-#line 4657
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(4657, ls != NULL);
+    IRO_ASSERT(4658, refcon != NULL);
 
     params = refcon;
 
     if (!params->xC && !LocationSet_IsUnknown(ls)) {
         value = params->x0;
         nd = params->nd;
-#line 4665
-        IRO_ASSERT(nd != NULL);
+        IRO_ASSERT(4665, nd != NULL);
         oper = nd->nodetype;
 
         stride = LocationSet_stride(ls);
@@ -3170,8 +3064,7 @@ static void EvalAssignAction2(LocationSet *ls, void *refcon) {
                     value = CInt64_Or(*((CInt64 *) PAMemoryBlock_thing(block)), value);
                     break;
                 default:
-#line 4746
-                    CError_FATAL();
+                    CError_FATAL(4746);
             }
 
             block = PAMemoryBlock_New();
@@ -3225,18 +3118,16 @@ static void EvalAssignAction(LocationSet *dst, void *refcon) {
     EvalAssignActionParams *params;
     LocationSetSet *srcs;
 
-#line 4797
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(4797, dst != NULL);
+    IRO_ASSERT(4798, refcon != NULL);
 
     params = refcon;
 
-#line 4802
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->srcs != NULL);
+    IRO_ASSERT(4802, params->proc != NULL);
+    IRO_ASSERT(4802, params->ptf != NULL);
+    IRO_ASSERT(4803, params->nd != NULL);
+    IRO_ASSERT(4804, params->fnode != NULL);
+    IRO_ASSERT(4805, params->srcs != NULL);
 
     srcs = params->srcs;
     if (
@@ -3264,12 +3155,11 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
     PAMemoryBlock *block;
     Type *type;
 
-#line 4840
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4840, proc != NULL);
+    IRO_ASSERT(4841, nd != NULL);
+    IRO_ASSERT(4842, fnode != NULL);
+    IRO_ASSERT(4843, map != NULL);
+    IRO_ASSERT(4844, ptf != NULL);
 
     memset(&params, 0, sizeof(params));
     params.proc = proc;
@@ -3285,8 +3175,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
     LocationSetSet_Init(params.srcs);
 
     if (nd->type == IROLinearOp2Arg) {
-#line 4861
-        IRO_ASSERT(nd->u.diadic.left->type == IROLinearOp1Arg && nd->u.diadic.left->nodetype == EINDIRECT);
+        IRO_ASSERT(4861, nd->u.diadic.left->type == IROLinearOp1Arg && nd->u.diadic.left->nodetype == EINDIRECT);
 
         params.x15 |= EvalExpr(set, proc, nd->u.diadic.left->u.monadic, &stCallingContextStack, map, ptf);
         AdjustTypesForVolatility(set, proc, nd->u.diadic.left);
@@ -3348,8 +3237,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
             }
         }
     } else if (nd->type == IROLinearOp1Arg) {
-#line 4958
-        IRO_ASSERT(nd->u.monadic.left->type == IROLinearOp1Arg && nd->u.monadic->nodetype == EINDIRECT);
+        IRO_ASSERT(4958, nd->u.monadic.left->type == IROLinearOp1Arg && nd->u.monadic->nodetype == EINDIRECT);
 
         params.x15 |= EvalExpr(set, proc, nd->u.monadic->u.monadic, &stCallingContextStack, map, ptf);
         AdjustTypesForVolatility(set, proc, nd->u.monadic);
@@ -3393,8 +3281,7 @@ static Boolean EvalAssign(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
                 break;
         }
     } else {
-#line 5006
-        CError_FATAL();
+        CError_FATAL(5006);
     }
 
     if (LocationSetSet_Count(params.srcs) != 0) {
@@ -3432,13 +3319,12 @@ static Boolean EvalReturn(Object *proc, IROLinear *nd, IRONode *fnode, ParamMapp
     EvalAssignActionParams params;
     LocationSet *loc;
 
-#line 5046
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(nd->type == IROLinearReturn);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(5046, proc != NULL);
+    IRO_ASSERT(5047, nd != NULL);
+    IRO_ASSERT(5048, nd->type == IROLinearReturn);
+    IRO_ASSERT(5049, fnode != NULL);
+    IRO_ASSERT(5050, map != NULL);
+    IRO_ASSERT(5051, ptf != NULL);
 
     memset(&params, 0, sizeof(params));
     params.proc = proc;
@@ -3496,33 +3382,29 @@ static void ApplySummaryAction2(ParamMapping *mapping, void *refcon) {
     LocationSetSet *set;
     EvalAssignActionParams assignParams;
 
-#line 5108
-    IRO_ASSERT(mapping != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5108, mapping != NULL);
+    IRO_ASSERT(5109, refcon != NULL);
 
     params = refcon;
 
-#line 5113
-    IRO_ASSERT(params->tgtMap != NULL);
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->nd->type == IROLinearFunccall);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->map != NULL);
-    IRO_ASSERT(params->loc != NULL);
-    IRO_ASSERT(params->locs != NULL);
+    IRO_ASSERT(5113, params->tgtMap != NULL);
+    IRO_ASSERT(5114, params->proc != NULL);
+    IRO_ASSERT(5115, params->fnode != NULL);
+    IRO_ASSERT(5116, params->nd != NULL);
+    IRO_ASSERT(5117, params->nd->type == IROLinearFunccall);
+    IRO_ASSERT(5118, params->ptf != NULL);
+    IRO_ASSERT(5119, params->map != NULL);
+    IRO_ASSERT(5120, params->loc != NULL);
+    IRO_ASSERT(5121, params->locs != NULL);
 
     block = LocationSet_block(params->loc);
 
-#line 5124
-    IRO_ASSERT(block != NULL);
-    IRO_ASSERT(PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
+    IRO_ASSERT(5124, block != NULL);
+    IRO_ASSERT(5125, PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM);
 
     ep = PAMemoryBlock_thing(block);
 
-#line 5127
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(5127, ep != NULL);
 
     if (ParamMapping_extended(mapping) == ep && (nd = ParamMapping_actual(mapping))) {
         set = LocationSetSet_New();
@@ -3564,26 +3446,23 @@ static void ApplySummaryAction(PointsToEntry *pte, void *refcon) {
     LocationSet *loc;
     PAMemoryBlock *block;
 
-#line 5175
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5175, pte != NULL);
+    IRO_ASSERT(5176, refcon != NULL);
 
     params = refcon;
 
-#line 5180
-    IRO_ASSERT(params->tgtMap != NULL);
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->nd->type == IROLinearFunccall);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->map != NULL);
+    IRO_ASSERT(5180, params->tgtMap != NULL);
+    IRO_ASSERT(5181, params->proc != NULL);
+    IRO_ASSERT(5182, params->fnode != NULL);
+    IRO_ASSERT(5183, params->nd != NULL);
+    IRO_ASSERT(5184, params->nd->type == IROLinearFunccall);
+    IRO_ASSERT(5185, params->ptf != NULL);
+    IRO_ASSERT(5186, params->map != NULL);
 
     loc = PointsToEntry_loc(pte);
 
-#line 5189
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(5189, loc != NULL);
+    IRO_ASSERT(5190, !LocationSet_IsUnknown(loc));
 
     block = LocationSet_block(loc);
     if (block && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
@@ -3598,15 +3477,14 @@ static Boolean ApplySummary(PartialTransferFunction *tgtPTF, ParamMappingFunctio
     ApplySummaryActionParams params;
     PointsToFunction *pointsToFunc;
 
-#line 5208
-    IRO_ASSERT(tgtPTF != NULL);
-    IRO_ASSERT(tgtMap != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(nd->type == IROLinearFunccall);
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(map != NULL);
+    IRO_ASSERT(5208, tgtPTF != NULL);
+    IRO_ASSERT(5209, tgtMap != NULL);
+    IRO_ASSERT(5210, proc != NULL);
+    IRO_ASSERT(5211, fnode != NULL);
+    IRO_ASSERT(5212, nd != NULL);
+    IRO_ASSERT(5213, nd->type == IROLinearFunccall);
+    IRO_ASSERT(5214, ptf != NULL);
+    IRO_ASSERT(5215, map != NULL);
 
     StoreReturnedLocations(nd, tgtPTF, tgtMap);
     if (tgtPTF == stUnknownPTF) {
@@ -3646,8 +3524,7 @@ static Boolean ApplySummary(PartialTransferFunction *tgtPTF, ParamMappingFunctio
 }
 
 static void GetPTFAction2(ParamMapping *mapping, void *refcon) {
-#line 5331
-    IRO_ASSERT(mapping != NULL);
+    IRO_ASSERT(5331, mapping != NULL);
 
     if (ParamMapping_extended(mapping))
         ParamMapping_SetExtended(mapping, NULL);
@@ -3672,19 +3549,17 @@ typedef struct GetPTFActionParams {
 static void GetPTFAction(PartialTransferFunction *tgtPTF, void *refcon) {
     GetPTFActionParams *params;
 
-#line 5359
-    IRO_ASSERT(tgtPTF != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5359, tgtPTF != NULL);
+    IRO_ASSERT(5360, refcon != NULL);
 
     params = refcon;
 
-#line 5364
-    IRO_ASSERT(params->map != NULL);
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->proc != &stUnknown);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->needVisit != NULL);
+    IRO_ASSERT(5364, params->map != NULL);
+    IRO_ASSERT(5365, params->proc != NULL);
+    IRO_ASSERT(5366, params->proc != &stUnknown);
+    IRO_ASSERT(5367, params->nd != NULL);
+    IRO_ASSERT(5368, params->ptf != NULL);
+    IRO_ASSERT(5369, params->needVisit != NULL);
 
     if (!params->x18) {
         if (MatchPTF(tgtPTF, params->proc, params->map, params->nd, params->ptf)) {
@@ -3704,12 +3579,11 @@ static PartialTransferFunction *GetPTF(ParamMappingFunction *map, Object *proc,
     PartialTransferFunction *result;
     GetPTFActionParams params;
 
-#line 5396
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(nd != NULL);
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(needVisit != NULL);
+    IRO_ASSERT(5396, map != NULL);
+    IRO_ASSERT(5397, proc != NULL);
+    IRO_ASSERT(5398, nd != NULL);
+    IRO_ASSERT(5399, ptf != NULL);
+    IRO_ASSERT(5400, needVisit != NULL);
 
     if (proc == &stUnknown) {
         result = stUnknownPTF;
@@ -3750,9 +3624,8 @@ static Boolean IsMeetNode(IRONode *fnode, IROLinear *nd) {
 }
 
 static Boolean IsExitNode(Object *proc, IRONode *fnode) {
-#line 5467
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
+    IRO_ASSERT(5467, proc != NULL);
+    IRO_ASSERT(5468, fnode != NULL);
 
     return (fnode->numsucc == 0) && Bv_IsBitSet(FunctionFirstNode(proc)->index, fnode->dom);
 }
@@ -3760,9 +3633,8 @@ static Boolean IsExitNode(Object *proc, IRONode *fnode) {
 static Boolean SomePredecessorHasBeenVisited(Object *proc, IRONode *fnode) {
     UInt16 i;
 
-#line 5479
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
+    IRO_ASSERT(5479, proc != NULL);
+    IRO_ASSERT(5480, fnode != NULL);
 
     for (i = 0; i < fnode->numpred; i++) {
         if (FunctionNodeTable(proc)[fnode->pred[i]]->x3C)
@@ -3775,8 +3647,8 @@ static Boolean SomePredecessorHasBeenVisited(Object *proc, IRONode *fnode) {
 static Boolean AllPredecessorsHaveBeenVisited(Object *proc, IRONode *fnode) {
     UInt16 i;
 
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(fnode != NULL);
+    IRO_ASSERT(0, proc != NULL);
+    IRO_ASSERT(0, fnode != NULL);
 
     for (i = 0; i < fnode->numpred; i++) {
         if (!FunctionNodeTable(proc)[fnode->pred[i]]->x3C)
@@ -3805,22 +3677,19 @@ static void EvalProcAction2(PointsToEntry *pte, void *refcon) {
     LocationSetSet *set;
     IRONode *node;
 
-#line 5525
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5525, pte != NULL);
+    IRO_ASSERT(5526, refcon != NULL);
 
     params = refcon;
 
-#line 5530
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->ptf != NULL);
+    IRO_ASSERT(5530, params->proc != NULL);
+    IRO_ASSERT(5531, params->fnode != NULL);
+    IRO_ASSERT(5532, params->ptf != NULL);
 
     dst = PointsToEntry_loc(pte);
 
-#line 5535
-    IRO_ASSERT(dst != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(dst));
+    IRO_ASSERT(5535, dst != NULL);
+    IRO_ASSERT(5536, !LocationSet_IsUnknown(dst));
 
     block = LocationSet_block(dst);
 
@@ -3862,17 +3731,15 @@ static void AssignEachInPointsToFunctionAction(PointsToEntry *pte, void *refcon)
     LocationSet *dst;
     LocationSetSet *srcs;
 
-#line 5577
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5577, pte != NULL);
+    IRO_ASSERT(5578, refcon != NULL);
 
     params = refcon;
 
-#line 5582
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->nd != NULL);
-    IRO_ASSERT(params->fnode != NULL);
-    IRO_ASSERT(params->ptf != NULL);
+    IRO_ASSERT(5582, params->proc != NULL);
+    IRO_ASSERT(5583, params->nd != NULL);
+    IRO_ASSERT(5584, params->fnode != NULL);
+    IRO_ASSERT(5585, params->ptf != NULL);
 
     dst = PointsToEntry_loc(pte);
 
@@ -3888,14 +3755,12 @@ static void AssignEachInPointsToFunction(PointsToFunction *pointsTo, void *refco
     AssignEachInPointsToFunctionActionParams *params;
     PointsToFunction *pointsToFunc;
 
-#line 5602
-    IRO_ASSERT(pointsTo != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(5602, pointsTo != NULL);
+    IRO_ASSERT(5603, refcon != NULL);
 
     params = refcon;
 
-#line 5607
-    IRO_ASSERT(params->nd != NULL);
+    IRO_ASSERT(5607, params->nd != NULL);
 
     pointsToFunc = PointsToFunction_New();
     if (params->nd->pointsToFunction)
@@ -3929,10 +3794,9 @@ static void AssignEachInPointsToFunction(PointsToFunction *pointsTo, void *refco
 static Boolean ObjectIsAFunctionArgument(Object *proc, Object *obj) {
     ObjectList *list;
 
-#line 5643
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(proc != &stUnknown);
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(5643, proc != NULL);
+    IRO_ASSERT(5644, proc != &stUnknown);
+    IRO_ASSERT(5645, obj != NULL);
 
     if (obj->datatype == DLOCAL) {
         for (list = FunctionArguments(proc); list; list = list->next) {
@@ -3947,10 +3811,9 @@ static Boolean ObjectIsAFunctionArgument(Object *proc, Object *obj) {
 static Boolean ObjectIsARealFunctionArgument(Object *proc, Object *obj) {
     ObjectList *list;
 
-#line 5661
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(proc != &stUnknown);
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(5661, proc != NULL);
+    IRO_ASSERT(5662, proc != &stUnknown);
+    IRO_ASSERT(5663, obj != NULL);
 
     if (obj->datatype == DLOCAL && proc == cscope_currentfunc) {
         for (list = arguments; list; list = list->next) {
@@ -3963,10 +3826,9 @@ static Boolean ObjectIsARealFunctionArgument(Object *proc, Object *obj) {
 }
 
 static void AddLocalVarsAddressedByExceptionUses(Object *var) {
-#line 5699
-    IRO_ASSERT(var != NULL);
-    IRO_ASSERT(stExceptionFNode != NULL);
-    IRO_ASSERT(stExceptionFNode->addressed != NULL);
+    IRO_ASSERT(5699, var != NULL);
+    IRO_ASSERT(5700, stExceptionFNode != NULL);
+    IRO_ASSERT(5701, stExceptionFNode->addressed != NULL);
 
     if (var->datatype == DLOCAL)
         ObjectSet_sub_4867D0(stExceptionFNode->addressed, var);
@@ -4020,9 +3882,8 @@ static void EvalProcAction(IROLinear *Int, Boolean flag) {
     static int userBreakCounter;
 
     if (!flag && !Int->x1E) {
-#line 5748
-        IRO_ASSERT(Int != NULL);
-        IRO_ASSERT(stEvalProcActionParams.changed != NULL);
+        IRO_ASSERT(5748, Int != NULL);
+        IRO_ASSERT(5749, stEvalProcActionParams.changed != NULL);
 
         proc = stEvalProcActionParams.proc;
         fnode = stEvalProcActionParams.fnode;
@@ -4033,11 +3894,10 @@ static void EvalProcAction(IROLinear *Int, Boolean flag) {
         x18 = stEvalProcActionParams.x18;
         x19 = stEvalProcActionParams.x19;
 
-#line 5760
-        IRO_ASSERT(proc != NULL);
-        IRO_ASSERT(fnode != NULL);
-        IRO_ASSERT(map != NULL);
-        IRO_ASSERT(ptf != NULL);
+        IRO_ASSERT(5760, proc != NULL);
+        IRO_ASSERT(5761, fnode != NULL);
+        IRO_ASSERT(5762, map != NULL);
+        IRO_ASSERT(5763, ptf != NULL);
 
         if (++userBreakCounter > 40) {
             IRO_CheckForUserBreak();
@@ -4145,10 +4005,9 @@ static void EvalProc(Object *proc, ParamMappingFunction *map, PartialTransferFun
     AssignEachInPointsToFunctionActionParams assignParams;
     EvalProcActionParams params;
 
-#line 5964
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(5964, proc != NULL);
+    IRO_ASSERT(5965, map != NULL);
+    IRO_ASSERT(5966, ptf != NULL);
 
     for (fnode = FunctionFirstNode(proc); fnode; fnode = fnode->nextnode)
         fnode->x3C = 0;
@@ -4213,10 +4072,8 @@ static void EvalProc(Object *proc, ParamMappingFunction *map, PartialTransferFun
         }
 
         clock();
-        if (++passCount > 32) {
-#line 6072
-            CError_FATAL();
-        }
+        if (++passCount > 32)
+            CError_FATAL(6072);
     } while (changed);
 
     if (passCount > stMaxPassCount)
@@ -4253,9 +4110,8 @@ static void CleanseLocationSet(LocationSet *loc, void *refcon) {
     PAMemoryBlock *block;
     PALocalVar *local;
 
-#line 6161
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(refcon == NULL);
+    IRO_ASSERT(6161, loc != NULL);
+    IRO_ASSERT(6162, refcon == NULL);
 
     if (
         !LocationSet_IsUnknown(loc) &&
@@ -4268,18 +4124,16 @@ static void CleanseLocationSet(LocationSet *loc, void *refcon) {
 }
 
 static void CleansePointsToEntry(PointsToEntry *pte, void *refcon) {
-#line 6177
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon == NULL);
+    IRO_ASSERT(6177, pte != NULL);
+    IRO_ASSERT(6178, refcon == NULL);
 
     CleanseLocationSet(PointsToEntry_loc(pte), NULL);
     LocationSetSet_ForEach(PointsToEntry_locs(pte), CleanseLocationSet, NULL);
 }
 
 static void PointerAnalysis_TermAction4(PartialTransferFunction *ptf, void *refcon) {
-#line 6187
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(refcon == NULL);
+    IRO_ASSERT(6187, ptf != NULL);
+    IRO_ASSERT(6188, refcon == NULL);
 
     if (ptf != stUnknownPTF) {
         PointsToFunction_ForEach(PartialTransferFunction_initialPointsToFn(ptf), CleansePointsToEntry, NULL);
@@ -4369,8 +4223,7 @@ static void InvalidatePointsToFunctions(Object *proc) {
     IRONode *fnode;
     IROLinear *nd;
 
-#line 6302
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(6302, proc != NULL);
 
     for (fnode = FunctionFirstNode(proc); fnode; fnode = fnode->nextnode) {
         if (fnode->last) {
@@ -4425,8 +4278,7 @@ void IRO_AnalyzePointers(Object *function) {
     int code;
     volatile heaperror_t saveheaperror;
 
-#line 6393
-    IRO_ASSERT(function != NULL);
+    IRO_ASSERT(6393, function != NULL);
 
     PointerAnalysis_Init();
 
@@ -4724,10 +4576,9 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
     LocationSet *tmp;
     PALocalVar *local;
 
-#line 6763
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(resultObj != NULL);
-    IRO_ASSERT(resultField != NULL);
+    IRO_ASSERT(6763, loc != NULL);
+    IRO_ASSERT(6764, resultObj != NULL);
+    IRO_ASSERT(6765, resultField != NULL);
 
     obj = NULL;
     field = LocationSet_field(loc);
@@ -4735,8 +4586,7 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
 
     if (block && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
         if ((ep = PAMemoryBlock_thing(block)) && (objSet = ExtendedParam_objectSet(ep))) {
-#line 6777
-            IRO_ASSERT(obj == NULL);
+            IRO_ASSERT(6777, obj == NULL);
             ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
         }
     }
@@ -4759,8 +4609,7 @@ static void GetDefiniteObjectOfExtendedParamLoc(LocationSet *loc, Object **resul
                 (objSet = ExtendedParam_objectSet(ep))
                 )
             {
-#line 6801
-                IRO_ASSERT(obj == NULL);
+                IRO_ASSERT(6801, obj == NULL);
                 ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
             } else if (
                 (block = LocationSet_block(tmp)) &&
@@ -4788,13 +4637,12 @@ static void CreateExpressionForLocationSet(LocationSet *loc, IROList *list, Type
     IROLinear *nd;
     Object *obj;
 
-#line 6833
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
-    IRO_ASSERT(LocationSet_stride(loc) == 0);
-    IRO_ASSERT(list != NULL);
-    IRO_ASSERT(rtype != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(6833, loc != NULL);
+    IRO_ASSERT(6834, !LocationSet_IsUnknown(loc));
+    IRO_ASSERT(6835, LocationSet_stride(loc) == 0);
+    IRO_ASSERT(6836, list != NULL);
+    IRO_ASSERT(6837, rtype != NULL);
+    IRO_ASSERT(6838, proc != NULL);
 
     field = LocationSet_field(loc);
     block = LocationSet_block(loc);
@@ -4834,8 +4682,7 @@ static void CreateExpressionForLocationSet(LocationSet *loc, IROList *list, Type
         case PAMEMORYBLOCKKIND_6:
             break;
         default:
-#line 6894
-            CError_FATAL();
+            CError_FATAL(6894);
     }
 
     if (nd && !CInt64_IsZero(&field)) {
@@ -4871,16 +4718,14 @@ static void LookupLinearExprAction(LocationSet *loc, void *refcon) {
     LookupLinearExprActionParams *params;
     IROListNode *list;
 
-#line 6926
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(6926, loc != NULL);
+    IRO_ASSERT(6927, refcon != NULL);
 
     params = refcon;
 
-#line 6931
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->indirectType != NULL);
-    IRO_ASSERT(params->list != NULL);
+    IRO_ASSERT(6931, params->proc != NULL);
+    IRO_ASSERT(6932, params->indirectType != NULL);
+    IRO_ASSERT(6933, params->list != NULL);
 
     list = *params->list = IRO_malloc(sizeof(IROListNode));
     IRO_InitList(&list->list);
@@ -4896,8 +4741,7 @@ void PointerAnalysis_LookupLinearNodePointerExpr(Object *proc, IROLinear *indire
     LocationSetSet *set;
     LookupLinearExprActionParams params;
 
-#line 6957
-    IRO_ASSERT(indirect != NULL);
+    IRO_ASSERT(6957, indirect != NULL);
 
     if (indirect->pointsToFunction) {
         set = LocationSetSet_New();
@@ -4923,12 +4767,12 @@ static void CreateENodeForLocationSet(LocationSet *loc, ENode **resultNode, Type
     ENode *nd;
     Object *obj;
 
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
-    IRO_ASSERT(LocationSet_stride(loc) == 0);
-    IRO_ASSERT(resultNode != NULL);
-    IRO_ASSERT(rtype != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(0, loc != NULL);
+    IRO_ASSERT(0, !LocationSet_IsUnknown(loc));
+    IRO_ASSERT(0, LocationSet_stride(loc) == 0);
+    IRO_ASSERT(0, resultNode != NULL);
+    IRO_ASSERT(0, rtype != NULL);
+    IRO_ASSERT(0, proc != NULL);
 
     field = LocationSet_field(loc);
     block = LocationSet_block(loc);
@@ -4963,8 +4807,7 @@ static void CreateENodeForLocationSet(LocationSet *loc, ENode **resultNode, Type
         case PAMEMORYBLOCKKIND_6:
             break;
         default:
-#line 7040
-            CError_FATAL();
+            CError_FATAL(7040);
     }
 
     if (nd && !CInt64_IsZero(&field)) {
@@ -5002,14 +4845,14 @@ static void LookupENodeExprAction(LocationSet *loc, void *refcon) {
     LookupENodeExprActionParams *params;
     ENodeList *list;
 
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(0, loc != NULL);
+    IRO_ASSERT(0, refcon != NULL);
 
     params = refcon;
 
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->indirectType != NULL);
-    IRO_ASSERT(params->list != NULL);
+    IRO_ASSERT(0, params->proc != NULL);
+    IRO_ASSERT(0, params->indirectType != NULL);
+    IRO_ASSERT(0, params->list != NULL);
 
     list = *params->list = IRO_malloc(sizeof(ENodeList));
     list->node = NULL;
@@ -5025,7 +4868,7 @@ void PointerAnalysis_LookupENodePointerExpr(Object *proc, ENode *indirect, ENode
     LocationSetSet *set;
     LookupENodeExprActionParams params;
 
-    IRO_ASSERT(indirect != NULL);
+    IRO_ASSERT(0, indirect != NULL);
 
     if (indirect->pointsTo) {
         set = LocationSetSet_New();
@@ -5043,7 +4886,7 @@ void PointerAnalysis_LookupENodePointerExpr(Object *proc, ENode *indirect, ENode
     }
 }
 
-void PointerAnalysis_LookupVariableIntoLinearNodeExprs(Object *proc, VarRecord *var, PointsToFunction *pointsTo, IROList **list) {
+void PointerAnalysis_LookupVariableIntoLinearNodeExprs(Object *proc, VarRecord *var, PointsToFunction *pointsTo, IROListNode **list) {
     LocationSetSet *set;
     LookupLinearExprActionParams params;
 
@@ -5106,18 +4949,16 @@ static void GetFunctionDepsOrKillsAction(LocationSet *ls, void *refcon) {
     PALocalVar *local;
     Object *obj;
 
-#line 7204
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(7204, ls != NULL);
+    IRO_ASSERT(7205, refcon != NULL);
 
     params = refcon;
 
-#line 7209
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->funccall != NULL);
-    IRO_ASSERT(params->map == NULL || params->map != NULL);
-    IRO_ASSERT(params->list != NULL);
+    IRO_ASSERT(7209, params->proc != NULL);
+    IRO_ASSERT(7210, params->ptf != NULL);
+    IRO_ASSERT(7211, params->funccall != NULL);
+    IRO_ASSERT(7212, params->map == NULL || params->map != NULL);
+    IRO_ASSERT(7213, params->list != NULL);
 
     list = *params->list = IRO_malloc(sizeof(ObjectList));
     list->object = NULL;
@@ -5128,8 +4969,7 @@ static void GetFunctionDepsOrKillsAction(LocationSet *ls, void *refcon) {
         switch (PAMemoryBlock_kind(block)) {
             case PAMEMORYBLOCKKIND_EXTENDEDPARAM:
                 if ((ep = PAMemoryBlock_thing(block)) && (objSet = ExtendedParam_objectSet(ep))) {
-#line 7232
-                    IRO_ASSERT(obj == NULL);
+                    IRO_ASSERT(7232, obj == NULL);
                     ObjectSet_ForEach(objSet, FindGlobalObjectAction, &obj);
                 }
                 break;
@@ -5154,23 +4994,20 @@ static void GetFunctionDepsOrKillsAction2(PointsToEntry *pte, void *refcon) {
     PAMemoryBlock *block;
     LocationSetSet *set;
 
-#line 7264
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(7264, pte != NULL);
+    IRO_ASSERT(7265, refcon != NULL);
 
     params = refcon;
 
-#line 7269
-    IRO_ASSERT(params->proc != NULL);
-    IRO_ASSERT(params->ptf != NULL);
-    IRO_ASSERT(params->funccall != NULL);
-    IRO_ASSERT(params->map != NULL);
-    IRO_ASSERT(params->list != NULL);
+    IRO_ASSERT(7269, params->proc != NULL);
+    IRO_ASSERT(7270, params->ptf != NULL);
+    IRO_ASSERT(7271, params->funccall != NULL);
+    IRO_ASSERT(7272, params->map != NULL);
+    IRO_ASSERT(7273, params->list != NULL);
 
     loc = PointsToEntry_loc(pte);
 
-#line 7277
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
+    IRO_ASSERT(7277, !LocationSet_IsUnknown(loc));
 
     if ((block = LocationSet_block(loc)) && PAMemoryBlock_kind(block) == PAMEMORYBLOCKKIND_EXTENDEDPARAM) {
         set = LocationSetSet_New();
@@ -5258,10 +5095,9 @@ void PointerAnalysis_GetFunctionKills(Object *proc, IROLinear *funccall, ObjectL
     LocationSetSet *set;
     GetFunctionDepsOrKillsActionParams params;
 
-#line 7398
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(funccall != NULL);
-    IRO_ASSERT(funccall->type == IROLinearFunccall);
+    IRO_ASSERT(7398, proc != NULL);
+    IRO_ASSERT(7399, funccall != NULL);
+    IRO_ASSERT(7400, funccall->type == IROLinearFunccall);
 
     if (!ObjectIsAFunction(proc))
         return;
@@ -5294,10 +5130,9 @@ void PointerAnalysis_GetFunctionDependencies(Object *proc, IROLinear *funccall,
     PointsToFunction *finalPointsTo;
     GetFunctionDepsOrKillsActionParams params;
 
-#line 7446
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(funccall != NULL);
-    IRO_ASSERT(funccall->type == IROLinearFunccall);
+    IRO_ASSERT(7446, proc != NULL);
+    IRO_ASSERT(7447, funccall != NULL);
+    IRO_ASSERT(7448, funccall->type == IROLinearFunccall);
 
     if (!ObjectIsAFunction(proc))
         return;
@@ -5373,15 +5208,14 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
     Boolean anotherFlag;
     Boolean isUnknown;
 
-#line 7552
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(rtype == NULL || rtype != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
-    IRO_ASSERT(resultFailed != NULL);
-    IRO_ASSERT(*resultFailed == false);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+    IRO_ASSERT(7552, loc != NULL);
+    IRO_ASSERT(7553, rtype == NULL || rtype != NULL);
+    IRO_ASSERT(7554, proc != NULL);
+    IRO_ASSERT(7555, createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
+    IRO_ASSERT(7556, resultFailed != NULL);
+    IRO_ASSERT(7557, *resultFailed == false);
+    IRO_ASSERT(7558, proc != NULL);
+    IRO_ASSERT(7559, proc == NULL || ObjectIsAFunction(proc));
 
     failed = 0;
     isUnknown = 0;
@@ -5484,8 +5318,7 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
                         }
                     } else {
                         ep = obj->extParam;
-#line 7687
-                        IRO_ASSERT(ep != NULL);
+                        IRO_ASSERT(7687, ep != NULL);
                     }
 
                     if (!failed) {
@@ -5625,15 +5458,14 @@ static void ParseLocationSet(LocationSet *loc, Type *rtype, Object *proc, Create
 static void ParseLocationSetSet(LocationSetSet *locs, Type *rtype, Object *proc, CreateNewParamObjects createNewParamObjects, Boolean *resultFailed) {
     Boolean failed;
 
-#line 7892
-    IRO_ASSERT(locs != NULL);
-    IRO_ASSERT(rtype == NULL || rtype != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
-    IRO_ASSERT(resultFailed != NULL);
-    IRO_ASSERT(*resultFailed == false);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+    IRO_ASSERT(7892, locs != NULL);
+    IRO_ASSERT(7893, rtype == NULL || rtype != NULL);
+    IRO_ASSERT(7894, proc != NULL);
+    IRO_ASSERT(7895, createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_FALSE || createNewParamObjects == CREATE_NEW_PARAM_OBJECTS_TRUE);
+    IRO_ASSERT(7896, resultFailed != NULL);
+    IRO_ASSERT(7897, *resultFailed == false);
+    IRO_ASSERT(7898, proc != NULL);
+    IRO_ASSERT(7899, proc == NULL || ObjectIsAFunction(proc));
 
     failed = 0;
 
@@ -5682,14 +5514,13 @@ static void ParseLocationSetSet(LocationSetSet *locs, Type *rtype, Object *proc,
 static Object *GetFunctionObjectFromDeclInfo(DeclInfo *di) {
     Object *proc;
 
-#line 7953
-    IRO_ASSERT(di != NULL);
+    IRO_ASSERT(7953, di != NULL);
 
     if (di->storageclass != TK_TYPEDEF && IS_TYPE_FUNC(di->thetype)) {
         Boolean flag;
         proc = CDecl_GetFunctionObject(di, NULL, &flag, 1);
         if (flag)
-            di->fileoffsetinfo.is_inline = 1;
+            di->x64 = 1;
     } else {
         proc = NULL;
     }
@@ -5702,17 +5533,14 @@ void PointerAnalysis_ParseEntryPointsToSpecifier(DeclInfo *di) {
     Boolean failed;
     Boolean anotherFlag;
 
-#line 7982
-    IRO_ASSERT(di != NULL);
+    IRO_ASSERT(7982, di != NULL);
 
     proc = GetFunctionObjectFromDeclInfo(di);
     if (proc) {
-#line 7987
-        IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+        IRO_ASSERT(7987, proc == NULL || ObjectIsAFunction(proc));
 
         tk = lex();
-#line 7996
-        IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"entry_points_to") == 0);
+        IRO_ASSERT(7996, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"entry_points_to") == 0);
 
         failed = 0;
 
@@ -5787,17 +5615,14 @@ void PointerAnalysis_ParseExitPointsToSpecifier(DeclInfo *di) {
     Boolean failed;
     Boolean anotherFlag;
 
-#line 8097
-    IRO_ASSERT(di != NULL);
+    IRO_ASSERT(8097, di != NULL);
 
     proc = GetFunctionObjectFromDeclInfo(di);
     if (proc) {
-#line 8102
-        IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+        IRO_ASSERT(8102, proc == NULL || ObjectIsAFunction(proc));
 
         tk = lex();
-#line 8111
-        IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"exit_points_to") == 0);
+        IRO_ASSERT(8111, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"exit_points_to") == 0);
 
         failed = 0;
 
@@ -5877,17 +5702,14 @@ void PointerAnalysis_ParseFunctionModifiesSpecifier(DeclInfo *di) {
     PartialTransferFunction *ptf;
     LocationSetSet *ptfLSS;
 
-#line 8211
-    IRO_ASSERT(di != NULL);
+    IRO_ASSERT(8211, di != NULL);
 
     proc = GetFunctionObjectFromDeclInfo(di);
     if (proc) {
-#line 8216
-        IRO_ASSERT(proc == NULL || ObjectIsAFunction(proc));
+        IRO_ASSERT(8216, proc == NULL || ObjectIsAFunction(proc));
 
         tk = lex();
-#line 8225
-        IRO_ASSERT(tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"function_modifies") == 0);
+        IRO_ASSERT(8225, tk == TK_IDENTIFIER && strcmp(tkidentifier->name,"function_modifies") == 0);
 
         failed = 0;
         lss = LocationSetSet_New();
diff --git a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
index baec435..cf54aca 100644
--- a/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
+++ b/compiler_and_linker/unsorted/IroPointerAnalysisADTs.c
@@ -43,17 +43,17 @@ typedef UInt32 uint32;
 void __assertion_failed(char *expr, char *filename, int line);
 
 #ifdef IRO_DEBUG
-#define IRO_ASSERT(expr) \
+#define IRO_ASSERT(line, expr) \
     do {                 \
        if (!(expr)) {    \
-           __assertion_failed(#expr, __FILE__, __LINE__); \
+           __assertion_failed(#expr, __FILE__, line); \
        }                 \
     } while (0);
 
 #define IRO_DEBUG_CLEAR(obj, type) \
     memset((obj), 0xFF, sizeof(type))
 #else
-#define IRO_ASSERT(expr) ((void) 0)
+#define IRO_ASSERT(line, expr) ((void) 0)
 #define IRO_DEBUG_CLEAR(obj, type) ((void) 0)
 #endif
 
@@ -222,8 +222,7 @@ inline void PTFList_RemoveAll(PTFList *ptfList);
 
 inline StackElement *StackElement_New(void) {
     StackElement *stackElement = IRO_malloc(sizeof(StackElement));
-#line 103
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(103, stackElement != NULL);
 #ifdef IRO_DEBUG
     stackElement->proc = NULL;
     stackElement->ptf = NULL;
@@ -234,23 +233,21 @@ inline StackElement *StackElement_New(void) {
 }
 
 inline void StackElement_Delete(StackElement *stackElement) {
-#line 117
-    IRO_ASSERT(stackElement != NULL);
-    IRO_ASSERT(stackElement->proc == NULL);
-    IRO_ASSERT(stackElement->ptf == NULL);
-    IRO_ASSERT(stackElement->map == NULL);
-    IRO_ASSERT(stackElement->funcCall == NULL);
+    IRO_ASSERT(117, stackElement != NULL);
+    IRO_ASSERT(118, stackElement->proc == NULL);
+    IRO_ASSERT(119, stackElement->ptf == NULL);
+    IRO_ASSERT(120, stackElement->map == NULL);
+    IRO_ASSERT(121, stackElement->funcCall == NULL);
     IRO_DEBUG_CLEAR(stackElement, sizeof(StackElement));
     IRO_free(stackElement);
 }
 
 inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialTransferFunction *ptf, ParamMappingFunction *map, IROLinear *funcCall) {
-#line 131
-    IRO_ASSERT(stackElement != NULL);
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(map != NULL);
-    IRO_ASSERT(funcCall != NULL);
+    IRO_ASSERT(131, stackElement != NULL);
+    IRO_ASSERT(132, proc != NULL);
+    IRO_ASSERT(133, ptf != NULL);
+    IRO_ASSERT(134, map != NULL);
+    IRO_ASSERT(135, funcCall != NULL);
     stackElement->proc = proc;
     stackElement->ptf = ptf;
     stackElement->map = map;
@@ -258,15 +255,13 @@ inline void StackElement_Init(StackElement *stackElement, Object *proc, PartialT
 }
 
 inline void StackElement_Copy(StackElement *dest, StackElement *src) {
-#line 145
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(145, dest != NULL);
+    IRO_ASSERT(146, src != NULL);
     StackElement_Init(dest, src->proc, src->ptf, src->map, src->funcCall);
 }
 
 inline void StackElement_Term(StackElement *stackElement) {
-#line 156
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(156, stackElement != NULL);
 #ifdef IRO_DEBUG
     stackElement->proc = NULL;
     stackElement->ptf = NULL;
@@ -276,46 +271,39 @@ inline void StackElement_Term(StackElement *stackElement) {
 }
 
 inline void *StackElement_sub_48A780(StackElement *stackElement) {
-#line 213
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(213, stackElement != NULL);
     return stackElement->proc;
 }
 
 inline Boolean StackRelated_sub_48A760(void *key1, void *key2) {
-#line 220
-    IRO_ASSERT(key1 != NULL);
-    IRO_ASSERT(key2 != NULL);
+    IRO_ASSERT(220, key1 != NULL);
+    IRO_ASSERT(221, key2 != NULL);
     return key1 == key2;
 }
 
 inline Object *StackElement_proc(StackElement *stackElement) {
-#line 228
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(228, stackElement != NULL);
     return stackElement->proc;
 }
 
 inline PartialTransferFunction *StackElement_ptf(StackElement *stackElement) {
-#line 235
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(235, stackElement != NULL);
     return stackElement->ptf;
 }
 
 inline ParamMappingFunction *StackElement_map(StackElement *stackElement) {
-#line 242
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(242, stackElement != NULL);
     return stackElement->map;
 }
 
 inline IROLinear *StackElement_funcCall(StackElement *stackElement) {
-#line 249
-    IRO_ASSERT(stackElement != NULL);
+    IRO_ASSERT(249, stackElement != NULL);
     return stackElement->funcCall;
 }
 
 inline Stack *Stack_New(void) {
     Stack *stack = IRO_malloc(sizeof(Stack));
-#line 265
-    IRO_ASSERT(stack != NULL);
+    IRO_ASSERT(265, stack != NULL);
 #ifdef IRO_DEBUG
     stack->top = NULL;
     stack->next = NULL;
@@ -324,17 +312,15 @@ inline Stack *Stack_New(void) {
 }
 
 inline void Stack_Delete(Stack *stack) {
-#line 277
-    IRO_ASSERT(stack != NULL);
-    IRO_ASSERT(stack->top == NULL);
-    IRO_ASSERT(stack->next == NULL);
+    IRO_ASSERT(277, stack != NULL);
+    IRO_ASSERT(278, stack->top == NULL);
+    IRO_ASSERT(279, stack->next == NULL);
     IRO_DEBUG_CLEAR(stack, sizeof(Stack));
     IRO_free(stack);
 }
 
 inline void Stack_Init(Stack *stack) {
-#line 289
-    IRO_ASSERT(stack != NULL);
+    IRO_ASSERT(289, stack != NULL);
     stack->top = NULL;
     stack->next = NULL;
 }
@@ -342,9 +328,8 @@ inline void Stack_Init(Stack *stack) {
 inline void Stack_Term(Stack **stackPtr) {
     StackElement *stackElement;
 
-#line 299
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(*stackPtr != NULL);
+    IRO_ASSERT(299, stackPtr != NULL);
+    IRO_ASSERT(300, *stackPtr != NULL);
 
     while ((*stackPtr)->top) {
         stackElement = Stack_sub_48A5B0(stackPtr);
@@ -357,9 +342,8 @@ inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
     StackElement *newElement;
     Stack *newStack;
 
-#line 315
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(*stackPtr != NULL);
+    IRO_ASSERT(315, stackPtr != NULL);
+    IRO_ASSERT(316, *stackPtr != NULL);
 
     newElement = StackElement_New();
     StackElement_Copy(newElement, stackElement);
@@ -371,17 +355,15 @@ inline void Stack_sub_48A660(Stack **stackPtr, StackElement *stackElement) {
 }
 
 inline StackElement *Stack_Top(Stack **stackPtr) {
-#line 331
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(*stackPtr != NULL);
+    IRO_ASSERT(331, stackPtr != NULL);
+    IRO_ASSERT(332, *stackPtr != NULL);
 
     return (*stackPtr)->top;
 }
 
 inline Stack *Stack_Next(Stack **stackPtr) {
-#line 343
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(*stackPtr != NULL);
+    IRO_ASSERT(343, stackPtr != NULL);
+    IRO_ASSERT(344, *stackPtr != NULL);
 
     return (*stackPtr)->next;
 }
@@ -389,9 +371,8 @@ inline Stack *Stack_Next(Stack **stackPtr) {
 inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
     StackElement *stackElement;
 
-#line 357
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(*stackPtr != NULL);
+    IRO_ASSERT(357, stackPtr != NULL);
+    IRO_ASSERT(358, *stackPtr != NULL);
 
     stackElement = (*stackPtr)->top;
     if (stackElement) {
@@ -408,9 +389,8 @@ inline StackElement *Stack_sub_48A5B0(Stack **stackPtr) {
 inline StackElement *Stack_sub_48A710(Stack **stackPtr, void *key) {
     Stack *stack;
 
-#line 379
-    IRO_ASSERT(stackPtr != NULL);
-    IRO_ASSERT(key != NULL);
+    IRO_ASSERT(379, stackPtr != NULL);
+    IRO_ASSERT(380, key != NULL);
 
     for (stack = *stackPtr; stack; stack = stack->next) {
         if (stack->top) {
@@ -426,8 +406,7 @@ inline ObjectSet *ObjectSet_New(void) {
     ObjectSet *procList;
 
     procList = IRO_malloc(sizeof(ObjectSet));
-#line 439
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(439, procList != NULL);
 #ifdef IRO_DEBUG
     procList->proc = NULL;
     procList->otherProcs = NULL;
@@ -436,24 +415,21 @@ inline ObjectSet *ObjectSet_New(void) {
 }
 
 inline void ObjectSet_Delete(ObjectSet *procList) {
-#line 451
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(procList->proc == NULL);
-    IRO_ASSERT(procList->otherProcs == NULL);
+    IRO_ASSERT(451, procList != NULL);
+    IRO_ASSERT(452, procList->proc == NULL);
+    IRO_ASSERT(453, procList->otherProcs == NULL);
     IRO_DEBUG_CLEAR(procList, sizeof(ObjectSet));
     IRO_free(procList);
 }
 
 inline void ObjectSet_Init(ObjectSet *procList) {
-#line 463
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(463, procList != NULL);
     procList->proc = NULL;
     procList->otherProcs = NULL;
 }
 
 inline void ObjectSet_Term(ObjectSet *procList) {
-#line 481
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(481, procList != NULL);
     ObjectSet_RemoveAll(procList);
 #ifdef IRO_DEBUG
     procList->proc = NULL;
@@ -462,10 +438,9 @@ inline void ObjectSet_Term(ObjectSet *procList) {
 }
 
 inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void *), void *refcon) {
-#line 528
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(action != NULL);
-    IRO_ASSERT(refcon == NULL || refcon != NULL);
+    IRO_ASSERT(528, procList != NULL);
+    IRO_ASSERT(529, action != NULL);
+    IRO_ASSERT(530, refcon == NULL || refcon != NULL);
 
     while (procList && procList->proc) {
         action(procList->proc, refcon);
@@ -474,9 +449,8 @@ inline void ObjectSet_ForEach(ObjectSet *procList, void (*action)(Object *, void
 }
 
 inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
-#line 540
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(540, procList != NULL);
+    IRO_ASSERT(541, proc != NULL);
     while (procList && procList->proc) {
         if (procList->proc == proc)
             return procList->proc;
@@ -486,16 +460,14 @@ inline Object *ObjectSet_sub_485020(ObjectSet *procList, Object *proc) {
 }
 
 inline Object *ObjectSet_FindFirst(ObjectSet *procList) {
-#line 552
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(552, procList != NULL);
     return procList->proc;
 }
 
 inline int ObjectSet_Count(ObjectSet *procList) {
     int count;
 
-#line 552
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(561, procList != NULL);
 
     count = 0;
     while (procList && procList->proc) {
@@ -509,9 +481,8 @@ inline int ObjectSet_Count(ObjectSet *procList) {
 inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
     ObjectSet *newProcList;
 
-#line 574
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(574, procList != NULL);
+    IRO_ASSERT(575, proc != NULL);
 
     if (procList->proc) {
         newProcList = ObjectSet_New();
@@ -525,9 +496,8 @@ inline void ObjectSet_sub_486800(ObjectSet *procList, Object *proc) {
 }
 
 inline void ObjectSet_sub_4867D0(ObjectSet *procList, Object *proc) {
-#line 592
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(592, procList != NULL);
+    IRO_ASSERT(593, proc != NULL);
 
     if (!ObjectSet_sub_485020(procList, proc))
         ObjectSet_sub_486800(procList, proc);
@@ -537,9 +507,8 @@ inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
     ObjectSet *prev;
     ObjectSet *tmp;
 
-#line 605
-    IRO_ASSERT(procList != NULL);
-    IRO_ASSERT(proc != NULL);
+    IRO_ASSERT(605, procList != NULL);
+    IRO_ASSERT(606, proc != NULL);
 
     prev = NULL;
     while (procList && procList->proc) {
@@ -571,33 +540,29 @@ inline void ObjectSet_Remove(ObjectSet *procList, Object *proc) {
 }
 
 inline void ObjectSet_RemoveAll(ObjectSet *procList) {
-#line 645
-    IRO_ASSERT(procList != NULL);
+    IRO_ASSERT(645, procList != NULL);
 
     while (procList && procList->proc)
         ObjectSet_Remove(procList, procList->proc);
 }
 
 inline void ObjectSet_AddSetAction(Object *proc, void *refcon) {
-#line 655
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(655, proc != NULL);
+    IRO_ASSERT(656, refcon != NULL);
 
     ObjectSet_sub_4867D0(refcon, proc);
 }
 
 inline void ObjectSet_SimpleAddSetAction(Object *proc, void *refcon) {
-#line 663
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(663, proc != NULL);
+    IRO_ASSERT(664, refcon != NULL);
 
     ObjectSet_sub_486800(refcon, proc);
 }
 
 inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
-#line 671
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(671, dest != NULL);
+    IRO_ASSERT(672, src != NULL);
 
     if (dest->proc)
         ObjectSet_ForEach(src, ObjectSet_AddSetAction, dest);
@@ -606,17 +571,15 @@ inline void ObjectSet_sub_48C590(ObjectSet *dest, ObjectSet *src) {
 }
 
 inline void ObjectSet_RemoveSetAction(Object *proc, void *refcon) {
-#line 682
-    IRO_ASSERT(proc != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(682, proc != NULL);
+    IRO_ASSERT(683, refcon != NULL);
 
     ObjectSet_Remove(refcon, proc);
 }
 
 inline void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) {
-#line 690
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(690, dest != NULL);
+    IRO_ASSERT(691, src != NULL);
 
     ObjectSet_ForEach(src, ObjectSet_RemoveSetAction, dest);
 }
@@ -624,9 +587,8 @@ inline void ObjectSet_removeiter_sub_48C890(ObjectSet *dest, ObjectSet *src) {
 inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
     ObjectSet *scan;
 
-#line 700
-    IRO_ASSERT(os1 != NULL);
-    IRO_ASSERT(os2 != NULL);
+    IRO_ASSERT(700, os1 != NULL);
+    IRO_ASSERT(701, os2 != NULL);
 
     if (os1 == os2)
         return 1;
@@ -647,8 +609,7 @@ inline Boolean ObjectSet_sub_484FA0(ObjectSet *os1, ObjectSet *os2) {
 inline ExtendedParam *ExtendedParam_New(void) {
     ExtendedParam *ep = IRO_malloc(sizeof(ExtendedParam));
 
-#line 755
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(755, ep != NULL);
 #ifdef IRO_DEBUG
     ep->objectSet = NULL;
 #endif
@@ -656,18 +617,17 @@ inline ExtendedParam *ExtendedParam_New(void) {
 }
 
 inline void ExtendedParam_Delete(ExtendedParam *ep) {
-    IRO_ASSERT(ep != NULL);
-    IRO_ASSERT(ep->objectSet == NULL);
+    IRO_ASSERT(762, ep != NULL);
+    IRO_ASSERT(763, ep->objectSet == NULL);
     IRO_DEBUG_CLEAR(ep, sizeof(ExtendedParam));
     IRO_free(ep);
 }
 
 inline void ExtendedParam_Init(ExtendedParam *ep, Object *obj) {
-#line 777
-    IRO_ASSERT(ep != NULL);
-    IRO_ASSERT(obj != NULL);
-    IRO_ASSERT(obj->extParam == NULL);
-    IRO_ASSERT(stExtendedParamNum < ((uint32) -1) / 2 - 1);
+    IRO_ASSERT(777, ep != NULL);
+    IRO_ASSERT(778, obj != NULL);
+    IRO_ASSERT(779, obj->extParam == NULL);
+    IRO_ASSERT(780, stExtendedParamNum < ((uint32) -1) / 2 - 1);
 
     ep->objectSet = ObjectSet_New();
     ObjectSet_Init(ep->objectSet);
@@ -682,7 +642,7 @@ inline void ExtendedParam_TermAction(Object *obj, void *refcon) {
 }
 
 inline void ExtendedParam_Term(ExtendedParam *ep) {
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(800, ep != NULL);
 
     ObjectSet_ForEach(ep->objectSet, ExtendedParam_TermAction, NULL);
     ObjectSet_Term(ep->objectSet);
@@ -693,11 +653,10 @@ inline void ExtendedParam_Term(ExtendedParam *ep) {
 }
 
 inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
-#line 841
-    IRO_ASSERT(ep1 != NULL);
-    IRO_ASSERT(ep2 != NULL);
-    IRO_ASSERT(ep1->objectSet != NULL);
-    IRO_ASSERT(ep2->objectSet != NULL);
+    IRO_ASSERT(841, ep1 != NULL);
+    IRO_ASSERT(842, ep2 != NULL);
+    IRO_ASSERT(843, ep1->objectSet != NULL);
+    IRO_ASSERT(844, ep2->objectSet != NULL);
 
     if (ep1 == ep2)
         return 1;
@@ -706,17 +665,15 @@ inline Boolean ExtendedParams_Equal(ExtendedParam *ep1, ExtendedParam *ep2) {
 }
 
 inline ExtendedParam *ExtendedParam_FindByObject(Object *obj) {
-#line 856
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(856, obj != NULL);
 
     return obj->extParam;
 }
 
 inline void ExtendedParam_sub_4867B0(ExtendedParam *ep, Object *obj) {
-#line 863
-    IRO_ASSERT(ep != NULL);
-    IRO_ASSERT(ep->objectSet != NULL);
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(863, ep != NULL);
+    IRO_ASSERT(864, ep->objectSet != NULL);
+    IRO_ASSERT(865, obj != NULL);
 
     ObjectSet_sub_4867D0(ep->objectSet, obj);
     obj->extParam = ep;
@@ -727,25 +684,22 @@ inline void ExtendedParam_RemoveObjectSetAction(Object *object, void *refcon) {
 }
 
 inline void EP_sub_48C850(ExtendedParam *ep, ObjectSet *objSet) {
-#line 888
-    IRO_ASSERT(ep != NULL);
-    IRO_ASSERT(ep->objectSet != NULL);
-    IRO_ASSERT(objSet != NULL);
+    IRO_ASSERT(888, ep != NULL);
+    IRO_ASSERT(889, ep->objectSet != NULL);
+    IRO_ASSERT(890, objSet != NULL);
 
     ObjectSet_removeiter_sub_48C890(ep->objectSet, objSet);
     ObjectSet_ForEach(objSet, ExtendedParam_RemoveObjectSetAction, NULL);
 }
 
 inline ObjectSet *ExtendedParam_objectSet(ExtendedParam *ep) {
-#line 898
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(898, ep != NULL);
 
     return ep->objectSet;
 }
 
 inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
-#line 905
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(905, ep != NULL);
 
     return ep->x4;
 }
@@ -753,8 +707,7 @@ inline uint32 ExtendedParam_sub_489110(ExtendedParam *ep) {
 inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
     ExtendedParamSet *epList = IRO_malloc(sizeof(ExtendedParamSet));
 
-#line 924
-    IRO_ASSERT(epList != NULL);
+    IRO_ASSERT(924, epList != NULL);
 #ifdef IRO_DEBUG
     epList->ep = NULL;
     epList->otherEps = NULL;
@@ -763,24 +716,21 @@ inline ExtendedParamSet *AllocsExtParamSet_sub_4876C0(void) {
 }
 
 inline void FreesExtParamSet_sub_48CAE0(ExtendedParamSet *epList) {
-#line 936
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(epList->ep == NULL);
-    IRO_ASSERT(epList->otherEps == NULL);
+    IRO_ASSERT(936, epList != NULL);
+    IRO_ASSERT(937, epList->ep == NULL);
+    IRO_ASSERT(938, epList->otherEps == NULL);
     IRO_DEBUG_CLEAR(epList, sizeof(ExtendedParamSet));
     IRO_free(epList);
 }
 
 inline void InitsExtParamSet_sub_4876A0(ExtendedParamSet *epList) {
-#line 948
-    IRO_ASSERT(epList != NULL);
+    IRO_ASSERT(948, epList != NULL);
     epList->ep = NULL;
     epList->otherEps = NULL;
 }
 
 inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
-#line 966
-    IRO_ASSERT(epList != NULL);
+    IRO_ASSERT(966, epList != NULL);
     ExtendedParamSet_RemoveAll(epList);
 #ifdef IRO_DEBUG
     epList->ep = NULL;
@@ -789,9 +739,8 @@ inline void TermsExtParamSet_sub_48CB00(ExtendedParamSet *epList) {
 }
 
 inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*action)(ExtendedParam *, void *), void *refcon) {
-#line 1010
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(action != NULL);
+    IRO_ASSERT(1010, epList != NULL);
+    IRO_ASSERT(1011, action != NULL);
 
     while (epList && epList->ep) {
         action(epList->ep, refcon);
@@ -800,9 +749,8 @@ inline void MaybeWalkExtParamSet_sub_48CBE0(ExtendedParamSet *epList, void (*act
 }
 
 inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1022
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(1022, epList != NULL);
+    IRO_ASSERT(1023, ep != NULL);
 
     while (epList && epList->ep) {
         if (epList->ep == ep)
@@ -814,9 +762,8 @@ inline ExtendedParam *ExtParamSet_sub_4876D0(ExtendedParamSet *epList, ExtendedP
 }
 
 inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1056
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(1056, epList != NULL);
+    IRO_ASSERT(1057, ep != NULL);
 
     if (epList->ep) {
         ExtendedParamSet *newSet = AllocsExtParamSet_sub_4876C0();
@@ -830,9 +777,8 @@ inline void ExtParamSet_sub_487660(ExtendedParamSet *epList, ExtendedParam *ep)
 }
 
 inline void ExtParamSet_sub_487630(ExtendedParamSet *epList, ExtendedParam *ep) {
-#line 1076
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(1076, epList != NULL);
+    IRO_ASSERT(1077, ep != NULL);
 
     if (!ExtParamSet_sub_4876D0(epList, ep))
         ExtParamSet_sub_487660(epList, ep);
@@ -842,9 +788,8 @@ inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep)
     ExtendedParamSet *prev;
     ExtendedParamSet *tmp;
 
-#line 1089
-    IRO_ASSERT(epList != NULL);
-    IRO_ASSERT(ep != NULL);
+    IRO_ASSERT(1089, epList != NULL);
+    IRO_ASSERT(1090, ep != NULL);
 
     prev = NULL;
     while (epList && epList->ep) {
@@ -876,8 +821,7 @@ inline void ExtendedParamSet_Remove(ExtendedParamSet *epList, ExtendedParam *ep)
 }
 
 inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
-#line 1129
-    IRO_ASSERT(epList != NULL);
+    IRO_ASSERT(1129, epList != NULL);
 
     while (epList && epList->ep)
         ExtendedParamSet_Remove(epList, epList->ep);
@@ -886,8 +830,7 @@ inline void ExtendedParamSet_RemoveAll(ExtendedParamSet *epList) {
 inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
     PAHeapBlock *hb = IRO_malloc(sizeof(PAHeapBlock));
 
-#line 1225
-    IRO_ASSERT(hb != NULL);
+    IRO_ASSERT(1225, hb != NULL);
 #ifdef IRO_DEBUG
     hb->parent = NULL;
 #endif
@@ -895,16 +838,14 @@ inline PAHeapBlock *CreateUniqueHeapAlloc_sub_486420(void) {
 }
 
 inline void InitUniqueHeapAlloc_sub_486410(PAHeapBlock *hb, IROLinear *nd) {
-#line 1247
-    IRO_ASSERT(hb != NULL);
+    IRO_ASSERT(1247, hb != NULL);
 
     hb->x0 = nd;
 }
 
 inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
-#line 1296
-    IRO_ASSERT(hb1 != NULL);
-    IRO_ASSERT(hb2 != NULL);
+    IRO_ASSERT(1296, hb1 != NULL);
+    IRO_ASSERT(1297, hb2 != NULL);
 
     return (hb1 == hb2) || (hb1->x0 == hb2->x0);
 }
@@ -912,8 +853,7 @@ inline Boolean PAHeapBlocks_Equal(PAHeapBlock *hb1, PAHeapBlock *hb2) {
 inline PALocalVar *PALocalVar_New(void) {
     PALocalVar *local = IRO_malloc(sizeof(PALocalVar));
 
-#line 1333
-    IRO_ASSERT(local != NULL);
+    IRO_ASSERT(1333, local != NULL);
 #ifdef IRO_DEBUG
     local->parent = NULL;
     local->nextSibling = NULL;
@@ -922,9 +862,8 @@ inline PALocalVar *PALocalVar_New(void) {
 }
 
 inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
-#line 1357
-    IRO_ASSERT(local != NULL);
-    IRO_ASSERT(obj != NULL);
+    IRO_ASSERT(1357, local != NULL);
+    IRO_ASSERT(1358, obj != NULL);
 
     local->x0 = obj;
     if (obj->name && obj->name->name) {
@@ -936,9 +875,8 @@ inline void PALocalVar_InitByObject(PALocalVar *local, Object *obj) {
 }
 
 inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
-#line 1372
-    IRO_ASSERT(local != NULL);
-    IRO_ASSERT(name != NULL);
+    IRO_ASSERT(1372, local != NULL);
+    IRO_ASSERT(1373, name != NULL);
 
     local->x0 = NULL;
     local->x4 = IRO_malloc(strlen(name) + 1);
@@ -946,9 +884,8 @@ inline void PALocalVar_InitByName(PALocalVar *local, char *name) {
 }
 
 inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
-#line 1419
-    IRO_ASSERT(local1 == NULL || local1 != NULL);
-    IRO_ASSERT(local2 == NULL || local2 != NULL);
+    IRO_ASSERT(1419, local1 == NULL || local1 != NULL);
+    IRO_ASSERT(1420, local2 == NULL || local2 != NULL);
 
     if (local1 == local2)
         return 1;
@@ -964,30 +901,26 @@ inline Boolean PALocalVars_Equal(PALocalVar *local1, PALocalVar *local2) {
 }
 
 inline void PALocalVar_SetSth_sub_4847C0(PALocalVar *local, Object *obj) {
-#line 1436
-    IRO_ASSERT(local != NULL);
-    IRO_ASSERT(obj == NULL || obj != NULL);
+    IRO_ASSERT(1436, local != NULL);
+    IRO_ASSERT(1437, obj == NULL || obj != NULL);
 
     local->x0 = obj;
 }
 
 inline Object *PALocalVar_Get0_sub_4847E0(PALocalVar *local) {
-#line 1444
-    IRO_ASSERT(local != NULL);
+    IRO_ASSERT(1444, local != NULL);
     return local->x0;
 }
 
 inline char *PALocalVar_Get4_sub_4847D0(PALocalVar *local) {
-#line 1451
-    IRO_ASSERT(local != NULL);
+    IRO_ASSERT(1451, local != NULL);
     return local->x4;
 }
 
 inline PAMemoryBlock *PAMemoryBlock_New(void) {
     PAMemoryBlock *mb = IRO_malloc(sizeof(PAMemoryBlock));
 
-#line 1491
-    IRO_ASSERT(mb != NULL);
+    IRO_ASSERT(1491, mb != NULL);
 #ifdef IRO_DEBUG
     mb->kind = PAMEMORYBLOCKKIND_INVALID;
 #endif
@@ -995,16 +928,14 @@ inline PAMemoryBlock *PAMemoryBlock_New(void) {
 }
 
 inline void PAMemoryBlock_Delete(PAMemoryBlock *mb) {
-#line 1502
-    IRO_ASSERT(mb != NULL);
-    IRO_ASSERT(mb->kind == PAMEMORYBLOCKKIND_INVALID);
+    IRO_ASSERT(1502, mb != NULL);
+    IRO_ASSERT(1503, mb->kind == PAMEMORYBLOCKKIND_INVALID);
     IRO_free(mb);
 }
 
 inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *thing) {
-#line 1513
-    IRO_ASSERT(mb != NULL);
-    IRO_ASSERT(thing == NULL || thing != NULL);
+    IRO_ASSERT(1513, mb != NULL);
+    IRO_ASSERT(1514, thing == NULL || thing != NULL);
 
     mb->kind = kind;
     switch (mb->kind) {
@@ -1024,14 +955,12 @@ inline void PAMemoryBlock_Init(PAMemoryBlock *mb, PAMemoryBlockKind kind, void *
             mb->u.x6 = (void *) thing;
             break;
         default:
-#line 1535
-            CError_FATAL();
+            CError_FATAL(1535);
     }
 }
 
 inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
-#line 1552
-    IRO_ASSERT(mb != NULL);
+    IRO_ASSERT(1552, mb != NULL);
 
 #ifdef IRO_DEBUG
     mb->kind = PAMEMORYBLOCKKIND_INVALID;
@@ -1039,9 +968,8 @@ inline void PAMemoryBlock_Term(PAMemoryBlock *mb) {
 }
 
 inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
-#line 1657
-    IRO_ASSERT(mb1 == NULL || mb1 != NULL);
-    IRO_ASSERT(mb2 == NULL || mb2 != NULL);
+    IRO_ASSERT(1657, mb1 == NULL || mb1 != NULL);
+    IRO_ASSERT(1658, mb2 == NULL || mb2 != NULL);
 
     if (mb1 == mb2)
         return 1;
@@ -1061,22 +989,19 @@ inline Boolean MemoryBlocks_Equal(PAMemoryBlock *mb1, PAMemoryBlock *mb2) {
         case PAMEMORYBLOCKKIND_6:
             return mb1->u.x6 == mb2->u.x6;
         default:
-#line 1684
-            CError_FATAL();
+            CError_FATAL(1684);
             return 0;
     }
 }
 
 inline PAMemoryBlockKind PAMemoryBlock_kind(PAMemoryBlock *mb) {
-#line 1692
-    IRO_ASSERT(mb != NULL);
+    IRO_ASSERT(1692, mb != NULL);
 
     return mb->kind;
 }
 
 inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
-#line 1699
-    IRO_ASSERT(mb != NULL);
+    IRO_ASSERT(1699, mb != NULL);
 
     switch (mb->kind) {
         case PAMEMORYBLOCKKIND_EXTENDEDPARAM:
@@ -1090,8 +1015,7 @@ inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
         case PAMEMORYBLOCKKIND_6:
             return mb->u.x6;
         default:
-#line 1719
-            CError_FATAL();
+            CError_FATAL(1719);
             return NULL;
     }
 }
@@ -1099,8 +1023,7 @@ inline void *PAMemoryBlock_thing(PAMemoryBlock *mb) {
 inline LocationSet *LocationSet_New(void) {
     LocationSet *ls = IRO_malloc(sizeof(LocationSet));
 
-#line 1767
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(1767, ls != NULL);
 #ifdef IRO_DEBUG
     ls->block = NULL;
     ls->rtype = NULL;
@@ -1111,23 +1034,21 @@ inline LocationSet *LocationSet_New(void) {
 }
 
 inline void LocationSet_Delete(LocationSet *ls) {
-#line 1781
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
-    IRO_ASSERT(ls->block == NULL);
-    IRO_ASSERT(CInt64_IsZero(&ls->u.known.field));
-    IRO_ASSERT(ls->u.known.stride == 0);
-    IRO_ASSERT(ls->rtype == NULL);
+    IRO_ASSERT(1781, ls != NULL);
+    IRO_ASSERT(1782, ls != stUnknownLs);
+    IRO_ASSERT(1783, ls->block == NULL);
+    IRO_ASSERT(1784, CInt64_IsZero(&ls->u.known.field));
+    IRO_ASSERT(1785, ls->u.known.stride == 0);
+    IRO_ASSERT(1786, ls->rtype == NULL);
     IRO_DEBUG_CLEAR(ls, sizeof(LocationSet));
     IRO_free(ls);
 }
 
 inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64 field, UInt32 stride, Type *rtype) {
-#line 1796
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
-    IRO_ASSERT(block != NULL);
-    IRO_ASSERT(rtype == NULL || rtype != NULL);
+    IRO_ASSERT(1796, ls != NULL);
+    IRO_ASSERT(1797, ls != stUnknownLs);
+    IRO_ASSERT(1798, block != NULL);
+    IRO_ASSERT(1799, rtype == NULL || rtype != NULL);
     ls->block = block;
     ls->rtype = rtype;
     ls->u.known.field = field;
@@ -1135,12 +1056,11 @@ inline void LocationSet_InitKnown(LocationSet *ls, PAMemoryBlock *block, CInt64
 }
 
 inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
-#line 1809
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
-    IRO_ASSERT(rtype == NULL || rtype != NULL);
-    IRO_ASSERT(restriction == NULL || restriction != NULL);
-    IRO_ASSERT(bitfieldOf == NULL || bitfieldOf != NULL);
+    IRO_ASSERT(1809, ls != NULL);
+    IRO_ASSERT(1810, ls != stUnknownLs);
+    IRO_ASSERT(1811, rtype == NULL || rtype != NULL);
+    IRO_ASSERT(1812, restriction == NULL || restriction != NULL);
+    IRO_ASSERT(1813, bitfieldOf == NULL || bitfieldOf != NULL);
 
     LocationSet_Copy(ls, stUnknownLs);
     ls->rtype = rtype;
@@ -1154,9 +1074,8 @@ inline void LocationSet_InitUnknown(LocationSet *ls, Type *rtype, PAMemoryBlock
 }
 
 inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
-#line 1829
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(1829, src != NULL);
+    IRO_ASSERT(1830, dest != NULL);
 
     dest->block = src->block;
     dest->rtype = src->rtype;
@@ -1176,9 +1095,8 @@ inline void LocationSet_Copy(LocationSet *dest, LocationSet *src) {
 }
 
 inline void LocationSet_Term(LocationSet *ls) {
-#line 1857
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
+    IRO_ASSERT(1857, ls != NULL);
+    IRO_ASSERT(1858, ls != stUnknownLs);
 
 #ifdef IRO_DEBUG
     if (LocationSet_IsUnknown(ls) && ls->u.unknown.bitfieldOf) {
@@ -1196,11 +1114,10 @@ inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet
     Boolean isUnknown1, isUnknown2;
     PAMemoryBlock *restriction1, *restriction2;
 
-#line 1974
-    IRO_ASSERT(ls1 != NULL);
-    IRO_ASSERT(rtype1 == NULL || rtype1 != NULL);
-    IRO_ASSERT(ls2 != NULL);
-    IRO_ASSERT(rtype2 == NULL || rtype2 != NULL);
+    IRO_ASSERT(1974, ls1 != NULL);
+    IRO_ASSERT(1975, rtype1 == NULL || rtype1 != NULL);
+    IRO_ASSERT(1976, ls2 != NULL);
+    IRO_ASSERT(1977, rtype2 == NULL || rtype2 != NULL);
 
     if (ls1 == ls2)
         return 1;
@@ -1296,9 +1213,8 @@ inline Boolean LocationSets_Overlap(LocationSet *ls1, Type *rtype1, LocationSet
 }
 
 inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
-#line 2080
-    IRO_ASSERT(ls1 != NULL);
-    IRO_ASSERT(ls2 != NULL);
+    IRO_ASSERT(2080, ls1 != NULL);
+    IRO_ASSERT(2081, ls2 != NULL);
 
     return
         (ls1 == ls2) ||
@@ -1319,9 +1235,8 @@ inline Boolean LocationSets_Equal(LocationSet *ls1, LocationSet *ls2) {
 }
 
 inline Boolean LocationSets_LookupCompatible(LocationSet *ls1, LocationSet *ls2) {
-#line 2119
-    IRO_ASSERT(ls1 != NULL);
-    IRO_ASSERT(ls2 != NULL);
+    IRO_ASSERT(2119, ls1 != NULL);
+    IRO_ASSERT(2120, ls2 != NULL);
 
     if (
         (ls1 == ls2) ||
@@ -1363,11 +1278,10 @@ inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet
     CInt64 longsize1;
     CInt64 longsize2;
 
-#line 2168
-    IRO_ASSERT(ls1 != NULL);
-    IRO_ASSERT(ls2 != NULL);
-    IRO_ASSERT(rtype1 != NULL);
-    IRO_ASSERT(rtype2 != NULL);
+    IRO_ASSERT(2168, ls1 != NULL);
+    IRO_ASSERT(2169, ls2 != NULL);
+    IRO_ASSERT(2170, rtype1 != NULL);
+    IRO_ASSERT(2171, rtype2 != NULL);
 
     if (ls1 == ls2)
         return 1;
@@ -1401,8 +1315,7 @@ inline Boolean LocationSet_Contains(LocationSet *ls1, Type *rtype1, LocationSet
 }
 
 inline Boolean LocationSet_IsUnknown(LocationSet *ls) {
-#line 2233
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2233, ls != NULL);
 
     return (ls == stUnknownLs) || (ls->block == stUnknownMb);
 }
@@ -1417,73 +1330,64 @@ inline Boolean LocationSet_sub_48AF30(LocationSet *ls) {
 }
 
 inline void LocationSet_SetRtype(LocationSet *ls, Type *rtype) {
-#line 2263
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
-    IRO_ASSERT(rtype != NULL);
+    IRO_ASSERT(2263, ls != NULL);
+    IRO_ASSERT(2264, ls != stUnknownLs);
+    IRO_ASSERT(2265, rtype != NULL);
 
     ls->rtype = rtype;
 }
 
 inline void SetsLocationSetField_sub_4851B0(LocationSet *ls, CInt64 field) {
-#line 2272
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2272, ls != NULL);
+    IRO_ASSERT(2273, !LocationSet_IsUnknown(ls));
 
     ls->u.known.field = field;
 }
 
 inline void SetsLocationSetStride_sub_4852D0(LocationSet *ls, SInt32 stride) {
-#line 2280
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2280, ls != NULL);
+    IRO_ASSERT(2281, !LocationSet_IsUnknown(ls));
 
     ls->u.known.stride = stride;
 }
 
 inline PAMemoryBlock *LocationSet_block(LocationSet *ls) {
-#line 2298
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2298, ls != NULL);
 
     return ls->block;
 }
 
 inline Type *LocationSet_rtype(LocationSet *ls) {
-#line 2306
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(ls != stUnknownLs);
+    IRO_ASSERT(2306, ls != NULL);
+    IRO_ASSERT(2307, ls != stUnknownLs);
 
     return ls->rtype;
 }
 
 inline CInt64 LocationSet_field(LocationSet *ls) {
-#line 2314
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2314, ls != NULL);
+    IRO_ASSERT(2315, !LocationSet_IsUnknown(ls));
 
     return ls->u.known.field;
 }
 
 inline UInt32 LocationSet_stride(LocationSet *ls) {
-#line 2322
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2322, ls != NULL);
+    IRO_ASSERT(2323, !LocationSet_IsUnknown(ls));
 
     return ls->u.known.stride;
 }
 
 inline PAMemoryBlock *LocationSet_restriction(LocationSet *ls) {
-#line 2330
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2330, ls != NULL);
+    IRO_ASSERT(2331, LocationSet_IsUnknown(ls));
 
     return ls->u.unknown.restriction;
 }
 
 inline LocationSet *LocationSet_bitfieldOf(LocationSet *ls) {
-#line 2338
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(LocationSet_IsUnknown(ls));
+    IRO_ASSERT(2338, ls != NULL);
+    IRO_ASSERT(2339, LocationSet_IsUnknown(ls));
 
     return ls->u.unknown.bitfieldOf;
 }
@@ -1491,8 +1395,7 @@ inline LocationSet *LocationSet_bitfieldOf(LocationSet *ls) {
 inline LocationSetSet *LocationSetSet_New() {
     LocationSetSet *lss = IRO_malloc(sizeof(LocationSetSet));
 
-#line 2356
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2356, lss != NULL);
 #ifdef IRO_DEBUG
     lss->loc = NULL;
     lss->otherLocs = NULL;
@@ -1502,18 +1405,16 @@ inline LocationSetSet *LocationSetSet_New() {
 }
 
 inline void LocationSetSet_Delete(LocationSetSet *lss) {
-#line 2369
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(lss->loc == NULL);
-    IRO_ASSERT(lss->otherLocs == NULL);
-    IRO_ASSERT(lss->count == 0);
+    IRO_ASSERT(2369, lss != NULL);
+    IRO_ASSERT(2370, lss->loc == NULL);
+    IRO_ASSERT(2371, lss->otherLocs == NULL);
+    IRO_ASSERT(2372, lss->count == 0);
     IRO_DEBUG_CLEAR(lss, sizeof(LocationSetSet));
     IRO_free(lss);
 }
 
 inline void LocationSetSet_Init(LocationSetSet *lss) {
-#line 2382
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2382, lss != NULL);
 
     lss->loc = NULL;
     lss->otherLocs = NULL;
@@ -1521,9 +1422,8 @@ inline void LocationSetSet_Init(LocationSetSet *lss) {
 }
 
 inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
-#line 2391
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(2391, dest != NULL);
+    IRO_ASSERT(2392, src != NULL);
 
     dest->loc = NULL;
     dest->otherLocs = NULL;
@@ -1532,8 +1432,7 @@ inline void LocationSetSet_Copy(LocationSetSet *dest, LocationSetSet *src) {
 }
 
 inline void LocationSetSet_Term(LocationSetSet *lss) {
-#line 2402
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2402, lss != NULL);
 
     LocationSetSet_RemoveAll(lss);
 
@@ -1545,10 +1444,9 @@ inline void LocationSetSet_Term(LocationSetSet *lss) {
 }
 
 inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationSet *, void *), void *refcon) {
-#line 2446
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(action != NULL);
-    IRO_ASSERT(refcon == NULL || refcon != NULL);
+    IRO_ASSERT(2446, lss != NULL);
+    IRO_ASSERT(2447, action != NULL);
+    IRO_ASSERT(2448, refcon == NULL || refcon != NULL);
 
     while (lss && lss->loc) {
         action(lss->loc, refcon);
@@ -1557,9 +1455,8 @@ inline void LocationSetSet_ForEach(LocationSetSet *lss, void (*action)(LocationS
 }
 
 inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
-#line 2458
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2458, lss != NULL);
+    IRO_ASSERT(2459, ls != NULL);
 
     while (lss && lss->loc) {
         if (LocationSets_Equal(lss->loc, ls))
@@ -1571,8 +1468,7 @@ inline LocationSet *LocationSetSet_Find(LocationSetSet *lss, LocationSet *ls) {
 }
 
 inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
-#line 2470
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2470, lss != NULL);
 
     if (!lss->loc)
         return stUnknownLs;
@@ -1587,15 +1483,13 @@ inline LocationSet *LocationSetSet_FindUnknown(LocationSetSet *lss) {
 }
 
 inline LocationSet *LocationSetSet_FindFirst(LocationSetSet *lss) {
-#line 2498
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2498, lss != NULL);
 
     return lss->loc;
 }
 
 inline int LocationSetSet_Count(LocationSetSet *lss) {
-#line 2505
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2505, lss != NULL);
 
     return lss->count;
 }
@@ -1606,9 +1500,8 @@ inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemor
     LocationSetSet *next;
     LocationSetSet *tmp;
 
-#line 2514
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(block != NULL);
+    IRO_ASSERT(2514, lss != NULL);
+    IRO_ASSERT(2515, block != NULL);
 
     first = lss;
     prev = NULL;
@@ -1649,9 +1542,8 @@ inline void LocationSetSet_RemoveAllWithMemoryBlock(LocationSetSet *lss, PAMemor
 }
 
 inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
-#line 2572
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2572, lss != NULL);
+    IRO_ASSERT(2573, ls != NULL);
 
     if (!LocationSet_IsUnknown(ls) && lss->count < 4) {
         LocationSet *ls2;
@@ -1692,9 +1584,8 @@ inline void LocationSetSet_SimpleAdd(LocationSetSet *lss, LocationSet *ls) {
 }
 
 inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
-#line 2622
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2622, lss != NULL);
+    IRO_ASSERT(2623, ls != NULL);
 
     if (!lss->loc || (!LocationSet_IsUnknown(lss->loc) && !LocationSetSet_Find(lss, ls))) {
         if (!LocationSet_IsUnknown(ls) && ls->u.known.stride)
@@ -1706,11 +1597,10 @@ inline void LocationSetSet_Add(LocationSetSet *lss, LocationSet *ls) {
 inline void LocationSetSet_AddUnknown(LocationSetSet *lss, Type *rtype, PAMemoryBlock *restriction, LocationSet *bitfieldOf) {
     LocationSet *ls;
 
-#line 2643
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(rtype == NULL || rtype != NULL);
-    IRO_ASSERT(restriction == NULL || restriction != NULL);
-    IRO_ASSERT(bitfieldOf == NULL || bitfieldOf != NULL);
+    IRO_ASSERT(2643, lss != NULL);
+    IRO_ASSERT(2644, rtype == NULL || rtype != NULL);
+    IRO_ASSERT(2645, restriction == NULL || restriction != NULL);
+    IRO_ASSERT(2646, bitfieldOf == NULL || bitfieldOf != NULL);
 
     ls = LocationSet_New();
     LocationSet_InitUnknown(ls, rtype, restriction, bitfieldOf);
@@ -1724,9 +1614,8 @@ inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
     LocationSetSet *first;
     LocationSetSet *tmp;
 
-#line 2659
-    IRO_ASSERT(lss != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(2659, lss != NULL);
+    IRO_ASSERT(2660, ls != NULL);
 
     first = lss;
     prev = NULL;
@@ -1765,33 +1654,29 @@ inline void LocationSetSet_Remove(LocationSetSet *lss, LocationSet *ls) {
 }
 
 inline void LocationSetSet_RemoveAll(LocationSetSet *lss) {
-#line 2707
-    IRO_ASSERT(lss != NULL);
+    IRO_ASSERT(2707, lss != NULL);
 
     while (lss && lss->loc)
         LocationSetSet_Remove(lss, lss->loc);
 }
 
 inline void LocationSetSet_AddSetAction(LocationSet *ls, void *refcon) {
-#line 2717
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2717, ls != NULL);
+    IRO_ASSERT(2718, refcon != NULL);
 
     LocationSetSet_Add((LocationSetSet *) refcon, ls);
 }
 
 inline void LocationSetSet_SimpleAddSetAction(LocationSet *ls, void *refcon) {
-#line 2725
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2725, ls != NULL);
+    IRO_ASSERT(2726, refcon != NULL);
 
     LocationSetSet_SimpleAdd((LocationSetSet *) refcon, ls);
 }
 
 inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
-#line 2733
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(2733, dest != NULL);
+    IRO_ASSERT(2734, src != NULL);
 
     if (dest->count)
         LocationSetSet_ForEach(src, LocationSetSet_AddSetAction, dest);
@@ -1800,25 +1685,22 @@ inline void LocationSetSet_AddSet(LocationSetSet *dest, LocationSetSet *src) {
 }
 
 inline void LocationSetSet_RemoveSetAction(LocationSet *ls, void *refcon) {
-#line 2744
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(2744, ls != NULL);
+    IRO_ASSERT(2745, refcon != NULL);
 
     LocationSetSet_Remove((LocationSetSet *) refcon, ls);
 }
 
 inline void LocationSetSet_sub_488700(LocationSetSet *dest, LocationSetSet *src) {
-#line 2752
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(2752, dest != NULL);
+    IRO_ASSERT(2753, src != NULL);
 
     LocationSetSet_ForEach(src, LocationSetSet_RemoveSetAction, dest);
 }
 
 inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2) {
-#line 2826
-    IRO_ASSERT(lss1 != NULL);
-    IRO_ASSERT(lss2 != NULL);
+    IRO_ASSERT(2826, lss1 != NULL);
+    IRO_ASSERT(2827, lss2 != NULL);
 
     if (lss1 == lss2)
         return 1;
@@ -1837,8 +1719,7 @@ inline Boolean LocationSetSets_Equal(LocationSetSet *lss1, LocationSetSet *lss2)
 inline ParamMapping *ParamMapping_New(void) {
     ParamMapping *pm = IRO_malloc(sizeof(ParamMapping));
 
-#line 2885
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(2885, pm != NULL);
 #ifdef IRO_DEBUG
     pm->actual = NULL;
     pm->formal = NULL;
@@ -1848,18 +1729,16 @@ inline ParamMapping *ParamMapping_New(void) {
 }
 
 inline void ParamMapping_Delete(ParamMapping *pm) {
-#line 2898
-    IRO_ASSERT(pm != NULL);
-    IRO_ASSERT(pm->actual == NULL);
-    IRO_ASSERT(pm->formal == NULL);
-    IRO_ASSERT(pm->extended == NULL);
+    IRO_ASSERT(2898, pm != NULL);
+    IRO_ASSERT(2899, pm->actual == NULL);
+    IRO_ASSERT(2900, pm->formal == NULL);
+    IRO_ASSERT(2901, pm->extended == NULL);
     IRO_DEBUG_CLEAR(pm, sizeof(ParamMapping));
     IRO_free(pm);
 }
 
 inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Object *formal, ExtendedParam *extended) {
-#line 2911
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(2911, pm != NULL);
 
     pm->actual = actual;
     pm->formal = formal;
@@ -1867,9 +1746,8 @@ inline void ParamMapping_Init_PROBABLY(ParamMapping *pm, IROLinear *actual, Obje
 }
 
 inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
-#line 2920
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(2920, src != NULL);
+    IRO_ASSERT(2921, dest != NULL);
 
     dest->actual = src->actual;
     dest->formal = src->formal;
@@ -1877,8 +1755,7 @@ inline void ParamMapping_Copy(ParamMapping *dest, ParamMapping *src) {
 }
 
 inline void ParamMapping_Term(ParamMapping *pm) {
-#line 2933
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(2933, pm != NULL);
 
 #ifdef IRO_DEBUG
     pm->actual = NULL;
@@ -1888,22 +1765,19 @@ inline void ParamMapping_Term(ParamMapping *pm) {
 }
 
 inline void ParamMapping_SetExtended(ParamMapping *pm, ExtendedParam *ep) {
-#line 2992
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(2992, pm != NULL);
 
     pm->extended = ep;
 }
 
 inline IROLinear *ParamMapping_actual(ParamMapping *pm) {
-#line 2999
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(2999, pm != NULL);
 
     return pm->actual;
 }
 
 inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
-#line 3011
-    IRO_ASSERT(pm != NULL);
+    IRO_ASSERT(3011, pm != NULL);
 
     return pm->extended;
 }
@@ -1911,8 +1785,7 @@ inline ExtendedParam *ParamMapping_extended(ParamMapping *pm) {
 inline ParamMappingFunction *ParamMappingFunction_New(void) {
     ParamMappingFunction *pmf = IRO_malloc(sizeof(ParamMappingFunction));
 
-#line 3026
-    IRO_ASSERT(pmf != NULL);
+    IRO_ASSERT(3026, pmf != NULL);
 #ifdef IRO_DEBUG
     pmf->mapping = NULL;
     pmf->otherMappings = NULL;
@@ -1921,26 +1794,23 @@ inline ParamMappingFunction *ParamMappingFunction_New(void) {
 }
 
 inline void ParamMappingFunction_Delete(ParamMappingFunction *pmf) {
-#line 3039
-    IRO_ASSERT(pmf != NULL);
-    IRO_ASSERT(pmf->mapping == NULL);
-    IRO_ASSERT(pmf->otherMappings == NULL);
+    IRO_ASSERT(3039, pmf != NULL);
+    IRO_ASSERT(3040, pmf->mapping == NULL);
+    IRO_ASSERT(3041, pmf->otherMappings == NULL);
     IRO_DEBUG_CLEAR(pmf, sizeof(ParamMappingFunction));
     IRO_free(pmf);
 }
 
 inline void ParamMappingFunction_Init(ParamMappingFunction *pmf) {
-#line 3050
-    IRO_ASSERT(pmf != NULL);
+    IRO_ASSERT(3050, pmf != NULL);
 
     pmf->mapping = NULL;
     pmf->otherMappings = NULL;
 }
 
 inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFunction *src) {
-#line 3058
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(3058, src != NULL);
+    IRO_ASSERT(3059, dest != NULL);
 
     dest->mapping = NULL;
     dest->otherMappings = NULL;
@@ -1948,8 +1818,7 @@ inline void ParamMappingFunction_Copy(ParamMappingFunction *dest, ParamMappingFu
 }
 
 inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
-#line 3068
-    IRO_ASSERT(pmf != NULL);
+    IRO_ASSERT(3068, pmf != NULL);
 
     ParamMappingFunction_RemoveAll(pmf);
 
@@ -1960,10 +1829,9 @@ inline void ParamMappingFunction_Term(ParamMappingFunction *pmf) {
 }
 
 inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMapping *, void *), void *refcon) {
-#line 3111
-    IRO_ASSERT(pmf != NULL);
-    IRO_ASSERT(action != NULL);
-    IRO_ASSERT(refcon == NULL || refcon != NULL);
+    IRO_ASSERT(3111, pmf != NULL);
+    IRO_ASSERT(3112, action != NULL);
+    IRO_ASSERT(3113, refcon == NULL || refcon != NULL);
 
     while (pmf && pmf->mapping) {
         action(pmf->mapping, refcon);
@@ -1972,9 +1840,8 @@ inline void pmf_sub_487C70(ParamMappingFunction *pmf, void (*action)(ParamMappin
 }
 
 inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFunction *pmf, Object *formal) {
-#line 3123
-    IRO_ASSERT(pmf != NULL);
-    IRO_ASSERT(formal != NULL);
+    IRO_ASSERT(3123, pmf != NULL);
+    IRO_ASSERT(3124, formal != NULL);
 
     while (pmf && pmf->mapping) {
         if (pmf->mapping->formal == formal)
@@ -1988,9 +1855,8 @@ inline ParamMapping *ParamMappingFunction_FindMappingByFormal(ParamMappingFuncti
 inline void Pmf_Add_sub_486610(ParamMappingFunction *pmf, ParamMapping *mapping) {
     ParamMapping *existing;
 
-#line 3138
-    IRO_ASSERT(pmf != NULL);
-    IRO_ASSERT(mapping != NULL);
+    IRO_ASSERT(3138, pmf != NULL);
+    IRO_ASSERT(3139, mapping != NULL);
 
     existing = ParamMappingFunction_FindMappingByFormal(pmf, mapping->formal);
     if (!existing) {
@@ -2014,9 +1880,8 @@ inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping
     ParamMappingFunction *prev;
     ParamMappingFunction *tmp;
 
-#line 3170
-    IRO_ASSERT(pmf != NULL);
-    IRO_ASSERT(mapping != NULL);
+    IRO_ASSERT(3170, pmf != NULL);
+    IRO_ASSERT(3171, mapping != NULL);
 
     prev = NULL;
     while (pmf && pmf->mapping) {
@@ -2051,25 +1916,22 @@ inline void ParamMappingFunction_Remove(ParamMappingFunction *pmf, ParamMapping
 }
 
 inline void ParamMappingFunction_RemoveAll(ParamMappingFunction *pmf) {
-#line 3213
-    IRO_ASSERT(pmf != NULL);
+    IRO_ASSERT(3213, pmf != NULL);
 
     while (pmf && pmf->mapping)
         ParamMappingFunction_Remove(pmf, pmf->mapping);
 }
 
 inline void ParamMappingFunction_AddFunctionAction(ParamMapping *mapping, void *refcon) {
-#line 3223
-    IRO_ASSERT(mapping != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3223, mapping != NULL);
+    IRO_ASSERT(3224, refcon != NULL);
 
     Pmf_Add_sub_486610((ParamMappingFunction *) refcon, mapping);
 }
 
 inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *dest, ParamMappingFunction *src) {
-#line 3231
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(3231, dest != NULL);
+    IRO_ASSERT(3232, src != NULL);
 
     pmf_sub_487C70(src, ParamMappingFunction_AddFunctionAction, dest);
 }
@@ -2077,8 +1939,7 @@ inline void ParamMappingFunction_AddAllMaybe_sub_487C50(ParamMappingFunction *de
 inline PointsToEntry *PointsToEntry_New(void) {
     PointsToEntry *pte = IRO_malloc(sizeof(PointsToEntry));
 
-#line 3288
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3288, pte != NULL);
 #ifdef IRO_DEBUG
     pte->loc = NULL;
     pte->locs = NULL;
@@ -2087,20 +1948,18 @@ inline PointsToEntry *PointsToEntry_New(void) {
 }
 
 inline void PointsToEntry_Delete(PointsToEntry *pte) {
-#line 3300
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(pte->loc == NULL);
-    IRO_ASSERT(pte->locs == NULL);
+    IRO_ASSERT(3300, pte != NULL);
+    IRO_ASSERT(3301, pte->loc == NULL);
+    IRO_ASSERT(3302, pte->locs == NULL);
     IRO_DEBUG_CLEAR(pte, sizeof(PointsToEntry));
     IRO_free(pte);
 }
 
 inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSetSet *locs) {
-#line 3312
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(loc != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(loc));
-    IRO_ASSERT(locs != NULL);
+    IRO_ASSERT(3312, pte != NULL);
+    IRO_ASSERT(3313, loc != NULL);
+    IRO_ASSERT(3314, !LocationSet_IsUnknown(loc));
+    IRO_ASSERT(3315, locs != NULL);
 
     pte->loc = LocationSet_New();
     LocationSet_Copy(pte->loc, loc);
@@ -2110,16 +1969,14 @@ inline void PointsToEntry_Init(PointsToEntry *pte, LocationSet *loc, LocationSet
 }
 
 inline void PointsToEntry_Copy(PointsToEntry *dest, PointsToEntry *src) {
-#line 3325
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(3325, src != NULL);
+    IRO_ASSERT(3326, dest != NULL);
 
     PointsToEntry_Init(dest, src->loc, src->locs);
 }
 
 inline void PointsToEntry_Term(PointsToEntry *pte) {
-#line 3333
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3333, pte != NULL);
 
     LocationSet_Term(pte->loc);
     LocationSet_Delete(pte->loc);
@@ -2133,9 +1990,8 @@ inline void PointsToEntry_Term(PointsToEntry *pte) {
 }
 
 inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
-#line 3381
-    IRO_ASSERT(pte1 != NULL);
-    IRO_ASSERT(pte2 != NULL);
+    IRO_ASSERT(3381, pte1 != NULL);
+    IRO_ASSERT(3382, pte2 != NULL);
 
     if (pte1 == pte2)
         return 1;
@@ -2144,15 +2000,13 @@ inline Boolean PointsToEntries_Equal(PointsToEntry *pte1, PointsToEntry *pte2) {
 }
 
 inline LocationSet *PointsToEntry_loc(PointsToEntry *pte) {
-#line 3407
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3407, pte != NULL);
 
     return pte->loc;
 }
 
 inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
-#line 3414
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3414, pte != NULL);
 
     return pte->locs;
 }
@@ -2160,8 +2014,7 @@ inline LocationSetSet *PointsToEntry_locs(PointsToEntry *pte) {
 inline PointsToFunction *PointsToFunction_New(void) {
     PointsToFunction *pointsToFunc = IRO_malloc(sizeof(PointsToFunction));
 
-#line 3430
-    IRO_ASSERT(pointsToFunc != NULL);
+    IRO_ASSERT(3430, pointsToFunc != NULL);
 #ifdef IRO_DEBUG
     pointsToFunc->pte = NULL;
     pointsToFunc->otherPtes = NULL;
@@ -2170,26 +2023,23 @@ inline PointsToFunction *PointsToFunction_New(void) {
 }
 
 inline void PointsToFunction_Delete(PointsToFunction *pointsToFunc) {
-#line 3442
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pointsToFunc->pte == NULL);
-    IRO_ASSERT(pointsToFunc->otherPtes == NULL);
+    IRO_ASSERT(3442, pointsToFunc != NULL);
+    IRO_ASSERT(3443, pointsToFunc->pte == NULL);
+    IRO_ASSERT(3444, pointsToFunc->otherPtes == NULL);
     IRO_DEBUG_CLEAR(pointsToFunc, sizeof(PointsToFunction));
     IRO_free(pointsToFunc);
 }
 
 inline void PointsToFunction_Init(PointsToFunction *pointsToFunc) {
-#line 3454
-    IRO_ASSERT(pointsToFunc != NULL);
+    IRO_ASSERT(3454, pointsToFunc != NULL);
 
     pointsToFunc->pte = NULL;
     pointsToFunc->otherPtes = NULL;
 }
 
 inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src) {
-#line 3462
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(3462, src != NULL);
+    IRO_ASSERT(3463, dest != NULL);
 
     dest->pte = NULL;
     dest->otherPtes = NULL;
@@ -2197,8 +2047,7 @@ inline void PointsToFunction_Copy(PointsToFunction *dest, PointsToFunction *src)
 }
 
 inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
-#line 3472
-    IRO_ASSERT(pointsToFunc != NULL);
+    IRO_ASSERT(3472, pointsToFunc != NULL);
 
     PointsToFunction_RemoveAll(pointsToFunc);
 
@@ -2209,10 +2058,9 @@ inline void PointsToFunction_Term(PointsToFunction *pointsToFunc) {
 }
 
 inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*action)(PointsToEntry *, void *), void *refcon) {
-#line 3515
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(action != NULL);
-    IRO_ASSERT(refcon == NULL || refcon != NULL);
+    IRO_ASSERT(3515, pointsToFunc != NULL);
+    IRO_ASSERT(3516, action != NULL);
+    IRO_ASSERT(3517, refcon == NULL || refcon != NULL);
 
     while (pointsToFunc && pointsToFunc->pte) {
         action(pointsToFunc->pte, refcon);
@@ -2221,9 +2069,8 @@ inline void PointsToFunction_ForEach(PointsToFunction *pointsToFunc, void (*acti
 }
 
 inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
-#line 3527
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(3527, pointsToFunc != NULL);
+    IRO_ASSERT(3528, ls != NULL);
 
     while (pointsToFunc && pointsToFunc->pte) {
         if (LocationSets_Equal(pointsToFunc->pte->loc, ls))
@@ -2235,16 +2082,14 @@ inline PointsToEntry *PointsToFunction_FindByLocationSet(PointsToFunction *point
 }
 
 inline PointsToEntry *PointsToFunction_FindFirst(PointsToFunction *pointsToFunc) {
-#line 3539
-    IRO_ASSERT(pointsToFunc != NULL);
+    IRO_ASSERT(3539, pointsToFunc != NULL);
 
     return pointsToFunc->pte;
 }
 
 inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls) {
-#line 3546
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(3546, pointsToFunc != NULL);
+    IRO_ASSERT(3547, ls != NULL);
 
     while (pointsToFunc && pointsToFunc->pte) {
         if (ls->u.known.stride) {
@@ -2260,10 +2105,9 @@ inline PointsToEntry *PointsToFunction_FindByLookupCompatibleLocationSet(PointsT
 }
 
 inline PointsToEntry *PointsToFunction_FindContainingLocationSet(PointsToFunction *pointsToFunc, LocationSet *ls, Type *rtype) {
-#line 3565
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(rtype != NULL);
+    IRO_ASSERT(3565, pointsToFunc != NULL);
+    IRO_ASSERT(3566, ls != NULL);
+    IRO_ASSERT(3567, rtype != NULL);
 
     while (pointsToFunc && pointsToFunc->pte) {
         if (pointsToFunc->pte->locs->loc && !LocationSet_IsUnknown(pointsToFunc->pte->locs->loc)) {
@@ -2284,18 +2128,16 @@ inline void PointsToFunction_RemoveOverlappingLocations(PointsToFunction *points
     PointsToFunction *next;
     PointsToFunction *tmp;
 
-#line 3601
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(pte->locs != NULL);
+    IRO_ASSERT(3601, pointsToFunc != NULL);
+    IRO_ASSERT(3602, pte != NULL);
+    IRO_ASSERT(3603, pte->locs != NULL);
 
     if (pte->locs->loc && pte->locs->loc != stUnknownLs)
         rtype1 = pte->locs->loc->rtype;
     else
         rtype1 = NULL;
     ls = pte->loc;
-#line 3614
-    IRO_ASSERT(ls != NULL);
+    IRO_ASSERT(3614, ls != NULL);
 
     prev = NULL;
     while (pointsToFunc && pointsToFunc->pte) {
@@ -2352,15 +2194,14 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
     Boolean flag2;
     Boolean flag3;
 
-#line 3675
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(pte->locs != NULL);
-    IRO_ASSERT(PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc) == NULL);
-    IRO_ASSERT((unknown = LocationSetSet_FindFirst(pte->locs)) != NULL);
-    IRO_ASSERT(LocationSet_IsUnknown(unknown));
-    IRO_ASSERT(LocationSet_bitfieldOf(unknown) == NULL);
-    IRO_ASSERT(LocationSet_restriction(unknown) == NULL);
+    IRO_ASSERT(3675, pointsToFunc != NULL);
+    IRO_ASSERT(3676, pte != NULL);
+    IRO_ASSERT(3677, pte->locs != NULL);
+    IRO_ASSERT(3678, PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc) == NULL);
+    IRO_ASSERT(3679, (unknown = LocationSetSet_FindFirst(pte->locs)) != NULL);
+    IRO_ASSERT(3680, LocationSet_IsUnknown(unknown));
+    IRO_ASSERT(3681, LocationSet_bitfieldOf(unknown) == NULL);
+    IRO_ASSERT(3682, LocationSet_restriction(unknown) == NULL);
 
     if (pte->locs->loc && pte->locs->loc != stUnknownLs)
         rtype1 = pte->locs->loc->rtype;
@@ -2368,8 +2209,7 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
         rtype1 = NULL;
 
     loc = pte->loc;
-#line 3693
-    IRO_ASSERT(loc != NULL);
+    IRO_ASSERT(3693, loc != NULL);
 
     isKnown = !LocationSet_IsUnknown(loc);
     if (isKnown)
@@ -2410,9 +2250,8 @@ inline Boolean ShouldAddNewPointsToEntryToFunction(PointsToFunction *pointsToFun
 inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     PointsToEntry *newPTE;
 
-#line 3741
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3741, pointsToFunc != NULL);
+    IRO_ASSERT(3742, pte != NULL);
 
     newPTE = PointsToEntry_New();
     PointsToEntry_Copy(newPTE, pte);
@@ -2428,9 +2267,8 @@ inline Boolean PointsToFunction_SimpleAdd(PointsToFunction *pointsToFunc, Points
 }
 
 inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
-#line 3766
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3766, pointsToFunc != NULL);
+    IRO_ASSERT(3767, pte != NULL);
 
     if (!PointsToFunction_FindByLookupCompatibleLocationSet(pointsToFunc, pte->loc)) {
         LocationSet *ls;
@@ -2449,9 +2287,8 @@ inline Boolean PointsToFunction_Add(PointsToFunction *pointsToFunc, PointsToEntr
 inline Boolean PointsToFunction_AddWithoutChecking(PointsToFunction *pointsToFunc, PointsToEntry *pte) {
     LocationSet *ls;
 
-#line 3793
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(pte != NULL);
+    IRO_ASSERT(3793, pointsToFunc != NULL);
+    IRO_ASSERT(3794, pte != NULL);
 
     if (!(ls = LocationSetSet_FindFirst(pte->locs)) || !LocationSet_IsUnknown(ls) || LocationSet_bitfieldOf(ls) ||
         LocationSet_restriction(ls) || ShouldAddNewPointsToEntryToFunction(pointsToFunc, pte)) {
@@ -2468,10 +2305,9 @@ inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc,
     PointsToFunction *prev;
     PointsToFunction *tmp;
 
-#line 3170
-    IRO_ASSERT(pointsToFunc != NULL);
-    IRO_ASSERT(ls != NULL);
-    IRO_ASSERT(!LocationSet_IsUnknown(ls));
+    IRO_ASSERT(3170, pointsToFunc != NULL);
+    IRO_ASSERT(3171, ls != NULL);
+    IRO_ASSERT(3172, !LocationSet_IsUnknown(ls));
 
     prev = NULL;
     while (pointsToFunc && pointsToFunc->pte) {
@@ -2506,33 +2342,29 @@ inline void PointsToFunction_RemoveByLocationSet(PointsToFunction *pointsToFunc,
 }
 
 inline void PointsToFunction_RemoveAll(PointsToFunction *pointsToFunc) {
-#line 3862
-    IRO_ASSERT(pointsToFunc != NULL);
+    IRO_ASSERT(3862, pointsToFunc != NULL);
 
     while (pointsToFunc && pointsToFunc->pte)
         PointsToFunction_RemoveByLocationSet(pointsToFunc, pointsToFunc->pte->loc);
 }
 
 inline void PointsToFunction_AddFunctionAction(PointsToEntry *pte, void *refcon) {
-#line 3872
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3872, pte != NULL);
+    IRO_ASSERT(3873, refcon != NULL);
 
     PointsToFunction_Add((PointsToFunction *) refcon, pte);
 }
 
 inline void PointsToFunction_SimpleAddFunctionAction(PointsToEntry *pte, void *refcon) {
-#line 3880
-    IRO_ASSERT(pte != NULL);
-    IRO_ASSERT(refcon != NULL);
+    IRO_ASSERT(3880, pte != NULL);
+    IRO_ASSERT(3881, refcon != NULL);
 
     PointsToFunction_SimpleAdd((PointsToFunction *) refcon, pte);
 }
 
 inline void PointsToFunction_AddAllIGuess_sub_487D80(PointsToFunction *dest, PointsToFunction *src) {
-#line 3888
-    IRO_ASSERT(dest != NULL);
-    IRO_ASSERT(src != NULL);
+    IRO_ASSERT(3888, dest != NULL);
+    IRO_ASSERT(3889, src != NULL);
 
     if (dest->pte)
         PointsToFunction_ForEach(src, PointsToFunction_AddFunctionAction, dest);
@@ -2589,9 +2421,8 @@ inline Boolean PointsToFunctions_Equal(PointsToFunction *pointsToFunc1, PointsTo
     PointsToFunction *scan;
     PointsToEntry *pte;
 
-#line 3968
-    IRO_ASSERT(pointsToFunc1 != NULL);
-    IRO_ASSERT(pointsToFunc2 != NULL);
+    IRO_ASSERT(3968, pointsToFunc1 != NULL);
+    IRO_ASSERT(3969, pointsToFunc2 != NULL);
 
     if (pointsToFunc1 == pointsToFunc2)
         return 1;
@@ -2618,8 +2449,7 @@ inline Boolean PointsToFunctions_Match(PointsToFunction *pointsToFunc1, PointsTo
 inline PartialTransferFunction *PartialTransferFunction_New() {
     PartialTransferFunction *ptf = IRO_malloc(sizeof(PartialTransferFunction));
 
-#line 4110
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4110, ptf != NULL);
 #ifdef IRO_DEBUG
     ptf->initialPointsToFn = NULL;
     ptf->finalPointsToFn = NULL;
@@ -2632,23 +2462,21 @@ inline PartialTransferFunction *PartialTransferFunction_New() {
 }
 
 inline void PartialTransferFunction_Delete(PartialTransferFunction *ptf) {
-#line 4126
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(ptf->initialPointsToFn == NULL);
-    IRO_ASSERT(ptf->finalPointsToFn == NULL);
-    IRO_ASSERT(ptf->funcModifies == NULL);
-    IRO_ASSERT(ptf->context.nd == NULL);
-    IRO_ASSERT(ptf->context.ptf == NULL);
-    IRO_ASSERT(ptf->returnLocation == NULL);
+    IRO_ASSERT(4126, ptf != NULL);
+    IRO_ASSERT(4127, ptf->initialPointsToFn == NULL);
+    IRO_ASSERT(4128, ptf->finalPointsToFn == NULL);
+    IRO_ASSERT(4129, ptf->funcModifies == NULL);
+    IRO_ASSERT(4130, ptf->context.nd == NULL);
+    IRO_ASSERT(4131, ptf->context.ptf == NULL);
+    IRO_ASSERT(4132, ptf->returnLocation == NULL);
     IRO_DEBUG_CLEAR(ptf, sizeof(PartialTransferFunction));
     IRO_free(ptf);
 }
 
 inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear *contextNd, PartialTransferFunction *contextPTF) {
-#line 4142
-    IRO_ASSERT(ptf != NULL);
-    IRO_ASSERT(contextNd != NULL);
-    IRO_ASSERT(contextPTF != NULL);
+    IRO_ASSERT(4142, ptf != NULL);
+    IRO_ASSERT(4143, contextNd != NULL);
+    IRO_ASSERT(4144, contextPTF != NULL);
 
     ptf->initialPointsToFn = PointsToFunction_New();
     PointsToFunction_Init(ptf->initialPointsToFn);
@@ -2667,9 +2495,8 @@ inline void PartialTransferFunction_Init(PartialTransferFunction *ptf, IROLinear
 }
 
 inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialTransferFunction *src) {
-#line 4164
-    IRO_ASSERT(src != NULL);
-    IRO_ASSERT(dest != NULL);
+    IRO_ASSERT(4164, src != NULL);
+    IRO_ASSERT(4165, dest != NULL);
 
     dest->initialPointsToFn = PointsToFunction_New();
     PointsToFunction_Copy(dest->initialPointsToFn, src->initialPointsToFn);
@@ -2691,8 +2518,7 @@ inline void PartialTransferFunction_Copy(PartialTransferFunction *dest, PartialT
 }
 
 inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
-#line 4190
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4190, ptf != NULL);
 
     PointsToFunction_Term(ptf->initialPointsToFn);
     PointsToFunction_Delete(ptf->initialPointsToFn);
@@ -2719,29 +2545,25 @@ inline void PartialTransferFunction_Term(PartialTransferFunction *ptf) {
 }
 
 inline PointsToFunction *PartialTransferFunction_initialPointsToFn(PartialTransferFunction *ptf) {
-#line 4221
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4221, ptf != NULL);
 
     return ptf->initialPointsToFn;
 }
 
 inline PointsToFunction *PartialTransferFunction_finalPointsToFn(PartialTransferFunction *ptf) {
-#line 4227
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4227, ptf != NULL);
 
     return ptf->finalPointsToFn;
 }
 
 inline LocationSetSet *PTF_sub_48D750(PartialTransferFunction *ptf) {
-#line 4233
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4233, ptf != NULL);
 
     return ptf->funcModifies;
 }
 
 inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFunction *ptf) {
-#line 4249
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4249, ptf != NULL);
 
     if (!ptf->returnLocation) {
         PAMemoryBlock *block;
@@ -2758,22 +2580,19 @@ inline LocationSet *PartialTransferFunction_returnLocation(PartialTransferFuncti
 }
 
 inline IROLinear *PTF_sub_48B980(PartialTransferFunction *ptf) {
-#line 4265
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4265, ptf != NULL);
 
     return ptf->context.nd;
 }
 
 inline PartialTransferFunction *PTF_sub_48B970(PartialTransferFunction *ptf) {
-#line 4271
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4271, ptf != NULL);
 
     return ptf->context.ptf;
 }
 
 inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boolean value) {
-#line 4298
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4298, ptf != NULL);
 
     ptf->x10 = (value != 0) ? 1 : 0;
 }
@@ -2781,8 +2600,7 @@ inline void PartialTransferFunction_sub_48A610(PartialTransferFunction *ptf, Boo
 inline PTFList *PTFList_New(void) {
     PTFList *ptfList = IRO_malloc(sizeof(PTFList));
 
-#line 4393
-    IRO_ASSERT(ptfList != NULL);
+    IRO_ASSERT(4393, ptfList != NULL);
 #ifdef IRO_DEBUG
     ptfList->ptf = NULL;
     ptfList->otherPTFs = NULL;
@@ -2791,25 +2609,22 @@ inline PTFList *PTFList_New(void) {
 }
 
 inline void PTFList_Delete(PTFList *ptfList) {
-#line 4405
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(ptfList->ptf == NULL);
-    IRO_ASSERT(ptfList->otherPTFs == NULL);
+    IRO_ASSERT(4405, ptfList != NULL);
+    IRO_ASSERT(4406, ptfList->ptf == NULL);
+    IRO_ASSERT(4407, ptfList->otherPTFs == NULL);
     IRO_DEBUG_CLEAR(ptfList, sizeof(PTFList));
     IRO_free(ptfList);
 }
 
 inline void PTFList_Init(PTFList *ptfList) {
-#line 4417
-    IRO_ASSERT(ptfList != NULL);
+    IRO_ASSERT(4417, ptfList != NULL);
 
     ptfList->ptf = NULL;
     ptfList->otherPTFs = NULL;
 }
 
 inline void PTFList_Term(PTFList *ptfList) {
-#line 4435
-    IRO_ASSERT(ptfList != NULL);
+    IRO_ASSERT(4435, ptfList != NULL);
 
     PTFList_RemoveAll(ptfList);
 
@@ -2820,10 +2635,9 @@ inline void PTFList_Term(PTFList *ptfList) {
 }
 
 inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunction *, void *), void *refcon) {
-#line 4478
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(action != NULL);
-    IRO_ASSERT(refcon == NULL || refcon != NULL);
+    IRO_ASSERT(4478, ptfList != NULL);
+    IRO_ASSERT(4479, action != NULL);
+    IRO_ASSERT(4480, refcon == NULL || refcon != NULL);
 
     while (ptfList && ptfList->ptf) {
         action(ptfList->ptf, refcon);
@@ -2832,9 +2646,8 @@ inline void PTFList_ForEach(PTFList *ptfList, void (*action)(PartialTransferFunc
 }
 
 inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4490
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4490, ptfList != NULL);
+    IRO_ASSERT(4491, ptf != NULL);
 
     while (ptfList && ptfList->ptf) {
         if (ptfList->ptf == ptf)
@@ -2847,16 +2660,14 @@ inline PartialTransferFunction *PTFList_sub_48A0F0(PTFList *ptfList, PartialTran
 }
 
 inline PartialTransferFunction *PTFList_FindFirst(PTFList *ptfList) {
-#line 4502
-    IRO_ASSERT(ptfList != NULL);
+    IRO_ASSERT(4502, ptfList != NULL);
 
     return ptfList->ptf;
 }
 
 inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4511
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4511, ptfList != NULL);
+    IRO_ASSERT(4512, ptf != NULL);
 
     if (ptfList->ptf) {
         PTFList *newList = PTFList_New();
@@ -2870,9 +2681,8 @@ inline void PTFList_sub_48A080(PTFList *ptfList, PartialTransferFunction *ptf) {
 }
 
 inline void PTFList_sub_48A050(PTFList *ptfList, PartialTransferFunction *ptf) {
-#line 4529
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4529, ptfList != NULL);
+    IRO_ASSERT(4530, ptf != NULL);
 
     if (!PTFList_sub_48A0F0(ptfList, ptf))
         PTFList_sub_48A080(ptfList, ptf);
@@ -2882,9 +2692,8 @@ inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
     PTFList *prev;
     PTFList *tmp;
 
-#line 4542
-    IRO_ASSERT(ptfList != NULL);
-    IRO_ASSERT(ptf != NULL);
+    IRO_ASSERT(4542, ptfList != NULL);
+    IRO_ASSERT(4543, ptf != NULL);
 
     prev = NULL;
     while (ptfList && ptfList->ptf) {
@@ -2917,8 +2726,7 @@ inline void PTFList_Remove(PTFList *ptfList, PartialTransferFunction *ptf) {
 }
 
 inline void PTFList_RemoveAll(PTFList *ptfList) {
-#line 4582
-    IRO_ASSERT(ptfList != NULL);
+    IRO_ASSERT(4582, ptfList != NULL);
 
     while (ptfList && ptfList->ptf)
         PTFList_Remove(ptfList, ptfList->ptf);
diff --git a/compiler_and_linker/unsorted/IroTransform.c b/compiler_and_linker/unsorted/IroTransform.c
index 710f2d8..e63421b 100644
--- a/compiler_and_linker/unsorted/IroTransform.c
+++ b/compiler_and_linker/unsorted/IroTransform.c
@@ -1,3 +1,2794 @@
 #include "compiler/IroTransform.h"
+#include "compiler/CError.h"
+#include "compiler/CFunc.h"
+#include "compiler/CInt64.h"
+#include "compiler/CIRTransform.h"
+#include "compiler/CMachine.h"
+#include "compiler/CPrep.h"
+#include "compiler/CompilerTools.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroLinearForm.h"
+#include "compiler/IroMalloc.h"
+#include "compiler/IroPointerAnalysis.h"
+#include "compiler/IROUseDef.h"
+#include "compiler/IroUtil.h"
+#include "compiler/IroVars.h"
+#include "compiler/enode.h"
+#include "compiler/types.h"
 
-// TODO
+ENodeType ExprType;
+ENode *IndirectRef;
+Boolean FirstTime;
+CInt64 OperandConst;
+Object *OperandObject;
+ENodeList *FirstAddend;
+ENodeList *LastAddend;
+static ENodeType AssignmentOp[MAXEXPR];
+static ENodeType ComplementaryOpLogical[MAXEXPR];
+static ENodeType ComplementaryOp[MAXEXPR];
+
+// forward decls
+static void DoDiadic(IROLinear *nd);
+
+static int GetTypeSize(Type *type) {
+    if (type->size == 1)
+        return 0;
+    if (type->size == 2)
+        return 1;
+    if (type->size == 4)
+        return 2;
+    if (type->size == 8)
+        return 3;
+    return -1;
+}
+
+void IRO_InitializeAssignmentOpArray(void) {
+    int i;
+
+    for (i = 0; i < MAXEXPR; i++)
+        AssignmentOp[i] = MAXEXPR;
+
+    AssignmentOp[EPOSTINC] = MAXEXPR;
+    AssignmentOp[EPOSTDEC] = MAXEXPR;
+    AssignmentOp[EPREINC] = MAXEXPR;
+    AssignmentOp[EPREDEC] = MAXEXPR;
+    AssignmentOp[EINDIRECT] = MAXEXPR;
+    AssignmentOp[EMONMIN] = MAXEXPR;
+    AssignmentOp[EBINNOT] = MAXEXPR;
+    AssignmentOp[ELOGNOT] = MAXEXPR;
+    AssignmentOp[EFORCELOAD] = MAXEXPR;
+    AssignmentOp[EMUL] = EMULASS;
+    AssignmentOp[EMULV] = MAXEXPR;
+    AssignmentOp[EDIV] = EDIVASS;
+    AssignmentOp[EMODULO] = EMODASS;
+    AssignmentOp[EADDV] = MAXEXPR;
+    AssignmentOp[ESUBV] = MAXEXPR;
+    AssignmentOp[EADD] = EADDASS;
+    AssignmentOp[ESUB] = ESUBASS;
+    AssignmentOp[ESHL] = ESHLASS;
+    AssignmentOp[ESHR] = ESHRASS;
+    AssignmentOp[ELESS] = MAXEXPR;
+    AssignmentOp[EGREATER] = MAXEXPR;
+    AssignmentOp[ELESSEQU] = MAXEXPR;
+    AssignmentOp[EGREATEREQU] = MAXEXPR;
+    AssignmentOp[EEQU] = MAXEXPR;
+    AssignmentOp[ENOTEQU] = MAXEXPR;
+    AssignmentOp[EAND] = EANDASS;
+    AssignmentOp[EXOR] = EXORASS;
+    AssignmentOp[EOR] = EORASS;
+    AssignmentOp[ELAND] = MAXEXPR;
+    AssignmentOp[ELOR] = MAXEXPR;
+    AssignmentOp[EASS] = MAXEXPR;
+    AssignmentOp[EMULASS] = MAXEXPR;
+    AssignmentOp[EDIVASS] = MAXEXPR;
+    AssignmentOp[EMODASS] = MAXEXPR;
+    AssignmentOp[EADDASS] = MAXEXPR;
+    AssignmentOp[ESUBASS] = MAXEXPR;
+    AssignmentOp[ESHLASS] = MAXEXPR;
+    AssignmentOp[ESHRASS] = MAXEXPR;
+    AssignmentOp[EANDASS] = MAXEXPR;
+    AssignmentOp[EXORASS] = MAXEXPR;
+    AssignmentOp[EORASS] = MAXEXPR;
+    AssignmentOp[ECOMMA] = MAXEXPR;
+    AssignmentOp[EPMODULO] = MAXEXPR;
+    AssignmentOp[EROTL] = MAXEXPR;
+    AssignmentOp[EROTR] = MAXEXPR;
+    AssignmentOp[EBCLR] = MAXEXPR;
+    AssignmentOp[EBTST] = MAXEXPR;
+    AssignmentOp[EBSET] = MAXEXPR;
+    AssignmentOp[ETYPCON] = MAXEXPR;
+    AssignmentOp[EBITFIELD] = MAXEXPR;
+    AssignmentOp[EINTCONST] = MAXEXPR;
+    AssignmentOp[EFLOATCONST] = MAXEXPR;
+    AssignmentOp[ESTRINGCONST] = MAXEXPR;
+    AssignmentOp[ECOND] = MAXEXPR;
+    AssignmentOp[EFUNCCALL] = MAXEXPR;
+    AssignmentOp[EFUNCCALLP] = MAXEXPR;
+    AssignmentOp[EOBJREF] = MAXEXPR;
+    AssignmentOp[EMFPOINTER] = MAXEXPR;
+    AssignmentOp[ENULLCHECK] = MAXEXPR;
+    AssignmentOp[EPRECOMP] = MAXEXPR;
+    AssignmentOp[ETEMP] = MAXEXPR;
+    AssignmentOp[EARGOBJ] = MAXEXPR;
+    AssignmentOp[ELOCOBJ] = MAXEXPR;
+    AssignmentOp[ELABEL] = MAXEXPR;
+    AssignmentOp[ESETCONST] = MAXEXPR;
+    AssignmentOp[ENEWEXCEPTION] = MAXEXPR;
+    AssignmentOp[ENEWEXCEPTIONARRAY] = MAXEXPR;
+    AssignmentOp[EOBJLIST] = MAXEXPR;
+    AssignmentOp[EMEMBER] = MAXEXPR;
+    AssignmentOp[ETEMPLDEP] = MAXEXPR;
+    AssignmentOp[EINSTRUCTION] = MAXEXPR;
+    AssignmentOp[EDEFINE] = MAXEXPR;
+    AssignmentOp[EREUSE] = MAXEXPR;
+    AssignmentOp[EASSBLK] = MAXEXPR;
+    AssignmentOp[EVECTOR128CONST] = MAXEXPR;
+    AssignmentOp[ECONDASS] = MAXEXPR;
+}
+
+void IRO_InitializeComplementaryOpArray(void) {
+    int i;
+
+    for (i = 0; i < MAXEXPR; i++)
+        ComplementaryOp[i] = MAXEXPR;
+
+    ComplementaryOp[EPOSTINC] = EPOSTDEC;
+    ComplementaryOp[EPOSTDEC] = EPOSTINC;
+    ComplementaryOp[EPREINC] = EPREDEC;
+    ComplementaryOp[EPREDEC] = EPREINC;
+    ComplementaryOp[EINDIRECT] = MAXEXPR;
+    ComplementaryOp[EMONMIN] = EMONMIN;
+    ComplementaryOp[EBINNOT] = EBINNOT;
+    ComplementaryOp[ELOGNOT] = ELOGNOT;
+    ComplementaryOp[EFORCELOAD] = MAXEXPR;
+    ComplementaryOp[EMUL] = EDIV;
+    ComplementaryOp[EMULV] = MAXEXPR;
+    ComplementaryOp[EDIV] = EMUL;
+    ComplementaryOp[EMODULO] = MAXEXPR;
+    ComplementaryOp[EADDV] = ESUBV;
+    ComplementaryOp[ESUBV] = EADDV;
+    ComplementaryOp[EADD] = ESUB;
+    ComplementaryOp[ESUB] = EADD;
+    ComplementaryOp[ESHL] = ESHR;
+    ComplementaryOp[ESHR] = ESHL;
+    ComplementaryOp[ELESS] = EGREATER;
+    ComplementaryOp[EGREATER] = ELESS;
+    ComplementaryOp[ELESSEQU] = EGREATEREQU;
+    ComplementaryOp[EGREATEREQU] = ELESSEQU;
+    ComplementaryOp[EEQU] = ENOTEQU;
+    ComplementaryOp[ENOTEQU] = EEQU;
+    ComplementaryOp[EAND] = EOR;
+    ComplementaryOp[EXOR] = MAXEXPR;
+    ComplementaryOp[EOR] = EAND;
+    ComplementaryOp[ELAND] = ELOR;
+    ComplementaryOp[ELOR] = ELAND;
+    ComplementaryOp[EASS] = MAXEXPR;
+    ComplementaryOp[EMULASS] = EDIVASS;
+    ComplementaryOp[EDIVASS] = EMULASS;
+    ComplementaryOp[EMODASS] = MAXEXPR;
+    ComplementaryOp[EADDASS] = ESUBASS;
+    ComplementaryOp[ESUBASS] = EADDASS;
+    ComplementaryOp[ESHLASS] = ESHRASS;
+    ComplementaryOp[ESHRASS] = ESHLASS;
+    ComplementaryOp[EANDASS] = EORASS;
+    ComplementaryOp[EXORASS] = MAXEXPR;
+    ComplementaryOp[EORASS] = EANDASS;
+    ComplementaryOp[ECOMMA] = MAXEXPR;
+    ComplementaryOp[EPMODULO] = MAXEXPR;
+    ComplementaryOp[EROTL] = EROTR;
+    ComplementaryOp[EROTR] = EROTL;
+    ComplementaryOp[EBCLR] = MAXEXPR;
+    ComplementaryOp[EBTST] = MAXEXPR;
+    ComplementaryOp[EBSET] = MAXEXPR;
+    ComplementaryOp[ETYPCON] = MAXEXPR;
+    ComplementaryOp[EBITFIELD] = MAXEXPR;
+    ComplementaryOp[EINTCONST] = MAXEXPR;
+    ComplementaryOp[EFLOATCONST] = MAXEXPR;
+    ComplementaryOp[ESTRINGCONST] = MAXEXPR;
+    ComplementaryOp[ECOND] = MAXEXPR;
+    ComplementaryOp[EFUNCCALL] = MAXEXPR;
+    ComplementaryOp[EFUNCCALLP] = MAXEXPR;
+    ComplementaryOp[EOBJREF] = MAXEXPR;
+    ComplementaryOp[EMFPOINTER] = MAXEXPR;
+    ComplementaryOp[ENULLCHECK] = MAXEXPR;
+    ComplementaryOp[EPRECOMP] = MAXEXPR;
+    ComplementaryOp[ETEMP] = MAXEXPR;
+    ComplementaryOp[EARGOBJ] = MAXEXPR;
+    ComplementaryOp[ELOCOBJ] = MAXEXPR;
+    ComplementaryOp[ELABEL] = MAXEXPR;
+    ComplementaryOp[ESETCONST] = MAXEXPR;
+    ComplementaryOp[ENEWEXCEPTION] = MAXEXPR;
+    ComplementaryOp[ENEWEXCEPTIONARRAY] = MAXEXPR;
+    ComplementaryOp[EOBJLIST] = MAXEXPR;
+    ComplementaryOp[EMEMBER] = MAXEXPR;
+    ComplementaryOp[ETEMPLDEP] = MAXEXPR;
+    ComplementaryOp[EINSTRUCTION] = MAXEXPR;
+    ComplementaryOp[EDEFINE] = MAXEXPR;
+    ComplementaryOp[EREUSE] = MAXEXPR;
+    ComplementaryOp[EASSBLK] = MAXEXPR;
+    ComplementaryOp[EVECTOR128CONST] = MAXEXPR;
+    ComplementaryOp[ECONDASS] = MAXEXPR;
+}
+
+void IRO_InitializeComplementaryOpLogicalArray(void) {
+    int i;
+
+    for (i = 0; i < MAXEXPR; i++)
+        ComplementaryOpLogical[i] = MAXEXPR;
+
+    ComplementaryOpLogical[EPOSTINC] = MAXEXPR;
+    ComplementaryOpLogical[EPOSTDEC] = MAXEXPR;
+    ComplementaryOpLogical[EPREINC] = MAXEXPR;
+    ComplementaryOpLogical[EPREDEC] = MAXEXPR;
+    ComplementaryOpLogical[EINDIRECT] = MAXEXPR;
+    ComplementaryOpLogical[EMONMIN] = MAXEXPR;
+    ComplementaryOpLogical[EBINNOT] = MAXEXPR;
+    ComplementaryOpLogical[ELOGNOT] = ELOGNOT;
+    ComplementaryOpLogical[EFORCELOAD] = MAXEXPR;
+    ComplementaryOpLogical[EMUL] = MAXEXPR;
+    ComplementaryOpLogical[EMULV] = MAXEXPR;
+    ComplementaryOpLogical[EDIV] = MAXEXPR;
+    ComplementaryOpLogical[EMODULO] = MAXEXPR;
+    ComplementaryOpLogical[EADDV] = MAXEXPR;
+    ComplementaryOpLogical[ESUBV] = MAXEXPR;
+    ComplementaryOpLogical[EADD] = MAXEXPR;
+    ComplementaryOpLogical[ESUB] = MAXEXPR;
+    ComplementaryOpLogical[ESHL] = MAXEXPR;
+    ComplementaryOpLogical[ESHR] = MAXEXPR;
+    ComplementaryOpLogical[ELESS] = EGREATEREQU;
+    ComplementaryOpLogical[EGREATER] = ELESSEQU;
+    ComplementaryOpLogical[ELESSEQU] = EGREATER;
+    ComplementaryOpLogical[EGREATEREQU] = ELESS;
+    ComplementaryOpLogical[EEQU] = ENOTEQU;
+    ComplementaryOpLogical[ENOTEQU] = EEQU;
+    ComplementaryOpLogical[EAND] = MAXEXPR;
+    ComplementaryOpLogical[EXOR] = MAXEXPR;
+    ComplementaryOpLogical[EOR] = MAXEXPR;
+    ComplementaryOpLogical[ELAND] = ELOR;
+    ComplementaryOpLogical[ELOR] = ELAND;
+    ComplementaryOpLogical[EASS] = MAXEXPR;
+    ComplementaryOpLogical[EMULASS] = MAXEXPR;
+    ComplementaryOpLogical[EDIVASS] = MAXEXPR;
+    ComplementaryOpLogical[EMODASS] = MAXEXPR;
+    ComplementaryOpLogical[EADDASS] = MAXEXPR;
+    ComplementaryOpLogical[ESUBASS] = MAXEXPR;
+    ComplementaryOpLogical[ESHLASS] = MAXEXPR;
+    ComplementaryOpLogical[ESHRASS] = MAXEXPR;
+    ComplementaryOpLogical[EANDASS] = MAXEXPR;
+    ComplementaryOpLogical[EXORASS] = MAXEXPR;
+    ComplementaryOpLogical[EORASS] = MAXEXPR;
+    ComplementaryOpLogical[ECOMMA] = MAXEXPR;
+    ComplementaryOpLogical[EPMODULO] = MAXEXPR;
+    ComplementaryOpLogical[EROTL] = MAXEXPR;
+    ComplementaryOpLogical[EROTR] = MAXEXPR;
+    ComplementaryOpLogical[EBCLR] = MAXEXPR;
+    ComplementaryOpLogical[EBTST] = MAXEXPR;
+    ComplementaryOpLogical[EBSET] = MAXEXPR;
+    ComplementaryOpLogical[ETYPCON] = MAXEXPR;
+    ComplementaryOpLogical[EBITFIELD] = MAXEXPR;
+    ComplementaryOpLogical[EINTCONST] = MAXEXPR;
+    ComplementaryOpLogical[EFLOATCONST] = MAXEXPR;
+    ComplementaryOpLogical[ESTRINGCONST] = MAXEXPR;
+    ComplementaryOpLogical[ECOND] = MAXEXPR;
+    ComplementaryOpLogical[EFUNCCALL] = MAXEXPR;
+    ComplementaryOpLogical[EFUNCCALLP] = MAXEXPR;
+    ComplementaryOpLogical[EOBJREF] = MAXEXPR;
+    ComplementaryOpLogical[EMFPOINTER] = MAXEXPR;
+    ComplementaryOpLogical[ENULLCHECK] = MAXEXPR;
+    ComplementaryOpLogical[EPRECOMP] = MAXEXPR;
+    ComplementaryOpLogical[ETEMP] = MAXEXPR;
+    ComplementaryOpLogical[EARGOBJ] = MAXEXPR;
+    ComplementaryOpLogical[ELOCOBJ] = MAXEXPR;
+    ComplementaryOpLogical[ELABEL] = MAXEXPR;
+    ComplementaryOpLogical[ESETCONST] = MAXEXPR;
+    ComplementaryOpLogical[ENEWEXCEPTION] = MAXEXPR;
+    ComplementaryOpLogical[ENEWEXCEPTIONARRAY] = MAXEXPR;
+    ComplementaryOpLogical[EOBJLIST] = MAXEXPR;
+    ComplementaryOpLogical[EMEMBER] = MAXEXPR;
+    ComplementaryOpLogical[ETEMPLDEP] = MAXEXPR;
+    ComplementaryOpLogical[EINSTRUCTION] = MAXEXPR;
+    ComplementaryOpLogical[EDEFINE] = MAXEXPR;
+    ComplementaryOpLogical[EREUSE] = MAXEXPR;
+    ComplementaryOpLogical[EASSBLK] = MAXEXPR;
+    ComplementaryOpLogical[EVECTOR128CONST] = MAXEXPR;
+    ComplementaryOpLogical[ECONDASS] = MAXEXPR;
+}
+
+static void DoTransformations(IROLinear *nd) {
+    IROLinear *nd2;
+    IROLinear *nd3;
+    IROLinear *nd4;
+    IROLinear *nd5;
+    Type *newtype;
+    SInt32 value;
+
+    if (nd->type == IROLinearOp2Arg) {
+        switch (nd->nodetype) {
+            case EASS:
+                nd2 = nd->u.diadic.right;
+                if (
+                    nd2->type == IROLinearOp2Arg &&
+                    AssignmentOp[nd2->nodetype] < MAXEXPR &&
+                    IRO_TypesEqual(nd->rtype, nd2->rtype) &&
+                    IRO_IsVariable(nd3 = nd->u.diadic.left) &&
+                    !(nd3->flags & IROLF_BitfieldIndirect) &&
+                    IRO_ExprsSame(nd3, nd2->u.diadic.left)
+                    )
+                {
+                    nd->nodetype = AssignmentOp[nd2->nodetype];
+                    nd->u.diadic.right = nd2->u.diadic.right;
+                    IRO_NopOut(nd2->u.diadic.left);
+                    nd2->type = IROLinearNop;
+
+                    nd3->flags |= IROLF_Used;
+                    nd3->u.diadic.left->flags |= IROLF_Used;
+                }
+                break;
+
+            case EMUL:
+                if (
+                    IS_TYPE_INT(nd->rtype) &&
+                    IRO_IsPow2(nd->u.diadic.right, &value)
+                    )
+                {
+                    nd->nodetype = ESHL;
+                    CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+                }
+                break;
+
+            case EDIV:
+                if (
+                    IS_TYPE_INT(nd->rtype) &&
+                    IRO_IsPow2(nd->u.diadic.right, &value)
+                    )
+                {
+                    if (IRO_IsUnsignedType(nd->rtype)) {
+                        nd->nodetype = ESHR;
+                        CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+                    } else if (
+                        !IRO_IsUnsignedType(nd->rtype) &&
+                        TYPE_INTEGRAL(nd->rtype)->integral != IT_BOOL &&
+                        nd->u.diadic.left->nodetype == ETYPCON &&
+                        IS_TYPE_INT(nd->u.diadic.left->u.monadic->rtype) &&
+                        IRO_IsUnsignedType(nd->u.diadic.left->u.monadic->rtype) &&
+                        nd->u.diadic.left->u.monadic->rtype->size < nd->u.diadic.left->rtype->size
+                        )
+                    {
+                        nd->nodetype = ESHR;
+                        CInt64_SetLong(&nd->u.diadic.right->u.node->data.intval, value);
+                        if (nd->flags & IROLF_Reffed) {
+                            IROLinear *copy = IRO_NewLinear(IROLinearOp1Arg);
+                            memcpy(copy, nd, sizeof(IROLinear));
+                            copy->type = IROLinearOp1Arg;
+                            copy->nodetype = ETYPCON;
+                            copy->index = IRO_NumLinear++;
+                            copy->rtype = nd->rtype;
+                            IRO_PasteAfter(copy, copy, nd);
+                            IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, copy);
+                            copy->u.monadic = nd;
+                            nd->flags |= IROLF_Reffed;
+                        }
+                        nd->rtype = IRO_UnsignedType(nd->rtype);
+                        newtype = IRO_UnsignedType(nd->u.diadic.right->rtype);
+                        nd->u.diadic.right->u.node->rtype = newtype;
+                        nd->u.diadic.right->rtype = newtype;
+                        nd->u.diadic.left->rtype = IRO_UnsignedType(nd->u.diadic.left->rtype);
+                    }
+                }
+                break;
+
+            case EMODULO:
+                if (
+                    IS_TYPE_INT(nd->rtype) &&
+                    IRO_IsUnsignedType(nd->rtype) &&
+                    IRO_IsPow2(nd->u.diadic.right, &value)
+                    )
+                {
+                    nd->nodetype = EAND;
+                    nd->u.diadic.right->u.node->data.intval = CInt64_Sub(nd->u.diadic.right->u.node->data.intval, cint64_one);
+                }
+                break;
+
+            case EEQU:
+                if (
+                    (nd2 = IRO_LocateFather(nd)) &&
+                    nd2->nodetype == ETYPCON &&
+                    IS_TYPE_INT(nd2->rtype) &&
+                    (nd3 = IRO_LocateFather(nd2)) &&
+                    nd3->nodetype == ELOGNOT &&
+                    (nd4 = IRO_LocateFather(nd3)) &&
+                    nd4->nodetype == ETYPCON &&
+                    IS_TYPE_INT(nd4->rtype) &&
+                    (
+                        ((nd5 = IRO_LocateFather(nd4)) && nd5->type == IROLinearIf) ||
+                        nd5->type == IROLinearIfNot
+                    )
+                    )
+                {
+                    IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd4, nd);
+                    nd->nodetype = ENOTEQU;
+                    nd2->type = IROLinearNop;
+                    nd3->type = IROLinearNop;
+                    nd4->type = IROLinearNop;
+                }
+                break;
+        }
+    }
+}
+
+static void IRO_SwitchChildren(IROLinear *nd) {
+    IROLinear *tmp = nd->u.diadic.left;
+    nd->u.diadic.left = nd->u.diadic.right;
+    nd->u.diadic.right = tmp;
+}
+
+static void ReplaceExprWithConst(IROLinear *nd, CInt64 val) {
+    IRO_NopOut(nd);
+    nd->type = IROLinearOperand;
+    nd->nodetype = EINTCONST;
+    nd->u.node = IRO_NewENode(EINTCONST);
+    nd->u.node->data.intval = val;
+    nd->u.node->flags = nd->nodeflags;
+    nd->u.node->rtype = nd->rtype;
+
+    if (IS_TYPE_FLOAT(nd->rtype)) {
+        nd->u.node->type = EFLOATCONST;
+        nd->nodetype = EFLOATCONST;
+        nd->u.node->data.floatval = CMach_CalcFloatConvertFromInt(TYPE(&stsignedlong), val);
+    }
+}
+
+static void ReplaceExprWithLeftChild(IROLinear *nd) {
+    IROLinear *left = nd->u.diadic.left;
+    IROLinear *right = nd->u.diadic.right;
+
+    if (left->rtype == nd->rtype) {
+        IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, left);
+        left->flags = nd->flags;
+        left->nodeflags = nd->nodeflags;
+        nd->type = IROLinearNop;
+        IRO_NopOut(right);
+    } else {
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = ETYPCON;
+        nd->u.monadic = left;
+        IRO_NopOut(right);
+    }
+}
+
+static void ReplaceExprWithRightChild(IROLinear *nd) {
+    IROLinear *left = nd->u.diadic.left;
+    IROLinear *right = nd->u.diadic.right;
+
+    if (right->rtype == nd->rtype) {
+        IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, right);
+        right->flags = nd->flags;
+        right->nodeflags = nd->nodeflags;
+        nd->type = IROLinearNop;
+        IRO_NopOut(left);
+    } else {
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = ETYPCON;
+        nd->u.monadic = right;
+        IRO_NopOut(left);
+    }
+}
+
+static void ReplaceExprWithMonaminRight(IROLinear *nd) {
+    IROLinear *left = nd->u.diadic.left;
+    IROLinear *right = nd->u.diadic.right;
+
+    if (right->rtype == nd->rtype) {
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = EMONMIN;
+        nd->u.monadic = right;
+        IRO_NopOut(left);
+    } else {
+        IRO_NopOut(left);
+        left->type = IROLinearOp1Arg;
+        left->nodetype = ETYPCON;
+        left->expr = right->expr;
+        left->rtype = nd->rtype;
+        left->u.monadic = right;
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = EMONMIN;
+        nd->u.monadic = left;
+    }
+}
+
+static void ReplaceExprWithMonaminLeft(IROLinear *nd) {
+    IROLinear *left = nd->u.diadic.left;
+    IROLinear *right = nd->u.diadic.right;
+
+    if (left->rtype == nd->rtype) {
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = EMONMIN;
+        nd->u.monadic = left;
+        IRO_NopOut(right);
+    } else {
+        IRO_NopOut(right);
+        right->type = IROLinearOp1Arg;
+        right->nodetype = ETYPCON;
+        right->expr = left->expr;
+        right->rtype = nd->rtype;
+        right->u.monadic = left;
+        nd->type = IROLinearOp1Arg;
+        nd->nodetype = EMONMIN;
+        nd->u.monadic = right;
+    }
+}
+
+static void switchFatherLeftMonadic(IROLinear *nd) {
+    IROLinear *inner = nd->u.monadic;
+    IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, inner);
+    nd->u.monadic = inner->u.monadic;
+    inner->u.monadic = nd;
+    inner->rtype = nd->rtype;
+    inner->flags = nd->flags;
+    inner->nodeflags = nd->nodeflags;
+    IRO_CutAndPasteAfter(inner, inner, nd);
+}
+
+static void switchFatherLeft(IROLinear *nd, int isRight) {
+    IROLinear *a;
+    IROLinear *b;
+
+    a = nd->u.diadic.left;
+    IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, a);
+
+    if (isRight) {
+        nd->u.diadic.left = a->u.diadic.left;
+        a->u.diadic.left = nd;
+        b = a->u.diadic.right;
+    } else {
+        nd->u.diadic.left = a->u.diadic.right;
+        a->u.diadic.right = nd;
+        b = a->u.diadic.left;
+    }
+
+    a->rtype = nd->rtype;
+    a->flags = nd->flags;
+    a->nodeflags = nd->nodeflags;
+    IRO_CutAndPasteAfter(a, a, nd);
+    IRO_CutAndPasteAfter(IRO_FindFirst(b), b, nd);
+}
+
+static void PickCommonsubAtLeftLeft(IROLinear *nd) {
+    switchFatherLeft(nd, 0);
+    ReplaceExprWithRightChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtRightLeft(IROLinear *nd) {
+    switchFatherLeft(nd, 1);
+    ReplaceExprWithRightChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtLeftRight(IROLinear *nd) {
+    switchFatherLeft(nd, 0);
+    ReplaceExprWithLeftChild(nd->u.diadic.right);
+}
+
+static void PickCommonsubAtRightRight(IROLinear *nd) {
+    switchFatherLeft(nd, 1);
+    ReplaceExprWithLeftChild(nd->u.diadic.right);
+}
+
+static void DoTransformations11(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+    int changed;
+    int compare;
+    Type *type;
+    SInt32 tmp1;
+    SInt32 tmp2;
+    CInt64 val;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+            return;
+
+        changed = 0;
+        if (!IRO_HasSideEffect(left) && !IRO_HasSideEffect(right)) {
+            if (IRO_IsIntConstant(right) || IRO_IsFloatConstant(right)) {
+                if (IRO_IsConstantZero(right)) {
+                    switch (nd->nodetype) {
+                        case EADDV:
+                        case ESUBV:
+                        case EADD:
+                        case ESUB:
+                        case ESHL:
+                        case ESHR:
+                        case EXOR:
+                        case EOR:
+                        case ELOR:
+                        case EADDASS:
+                        case ESUBASS:
+                        case ESHLASS:
+                        case ESHRASS:
+                        case EXORASS:
+                        case EORASS:
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                            break;
+                        case EMUL:
+                        case EAND:
+                        case ELAND:
+                            ReplaceExprWithConst(nd, cint64_zero);
+                            changed = 1;
+                            break;
+                        case EMULASS:
+                        case EANDASS:
+                            nd->nodetype = EASS;
+                            nd->u.diadic.right->rtype = nd->rtype;
+                            nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            changed = 1;
+                            break;
+                        case EDIV:
+                        case EMODULO:
+                        case EDIVASS:
+                        case EMODASS:
+                            if (nd->stmt->sourceoffset) {
+                                TStreamElement *token = CPrep_CurStreamElement();
+                                token->tokenoffset = nd->stmt->sourceoffset;
+                                CError_SetErrorToken(token);
+                            }
+                            CError_Warning(CErrorStr139);
+                            break;
+                    }
+                } else if (nd->nodetype == ELAND) {
+                    ReplaceExprWithLeftChild(nd);
+                    changed = 1;
+                } else if (nd->nodetype == ELOR) {
+                    ReplaceExprWithConst(nd, cint64_one);
+                    changed = 1;
+                } else if (nd->nodetype == ESHL || nd->nodetype == ESHR || nd->nodetype == ESHLASS || nd->nodetype == ESHRASS) {
+                    type = nd->rtype;
+                    tmp1 = type->size * 8;
+                    if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON) {
+                        type = left->u.monadic->rtype;
+                        if (
+                            left->u.monadic->type == IROLinearOp1Arg &&
+                            left->u.monadic->nodetype == EINDIRECT &&
+                            left->u.monadic->u.monadic->type == IROLinearOp1Arg &&
+                            left->u.monadic->u.monadic->nodetype == EBITFIELD &&
+                            IS_TYPE_BITFIELD(left->u.monadic->u.monadic->rtype)
+                            )
+                            tmp2 = TYPE_BITFIELD(left->u.monadic->u.monadic->rtype)->unkB;
+                        else
+                            tmp2 = type->size * 8;
+                    } else {
+                        tmp2 = tmp1;
+                    }
+
+                    switch (nd->nodetype) {
+                        case ESHL:
+                        case ESHLASS:
+                            CInt64_SetLong(&val, tmp1);
+                            if (IRO_IsUnsignedType(type))
+                                compare = CInt64_GreaterEqualU(right->u.node->data.intval, val);
+                            else
+                                compare = CInt64_GreaterEqual(right->u.node->data.intval, val);
+                            break;
+                        case ESHR:
+                        case ESHRASS:
+                            CInt64_SetLong(&val, tmp2);
+                            compare = IRO_IsUnsignedType(type) && CInt64_GreaterEqualU(right->u.node->data.intval, val);
+                            break;
+                    }
+
+                    if (compare) {
+                        switch (nd->nodetype) {
+                            case ESHL:
+                            case ESHR:
+                                ReplaceExprWithConst(nd, cint64_zero);
+                                break;
+                            case ESHLASS:
+                            case ESHRASS:
+                                nd->nodetype = EASS;
+                                ReplaceExprWithConst(right, cint64_zero);
+                                break;
+                        }
+                        changed = 1;
+                    }
+                } else if (IRO_IsConstantOne(right)) {
+                    switch (nd->nodetype) {
+                        case EMUL:
+                        case EMULV:
+                        case EDIV:
+                        case EMULASS:
+                        case EDIVASS:
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                            break;
+                        case EMODULO:
+                            ReplaceExprWithConst(nd, cint64_zero);
+                            changed = 1;
+                            break;
+                        case EMODASS:
+                            nd->nodetype = EASS;
+                            ReplaceExprWithConst(right, cint64_zero);
+                            nd->u.diadic.right->rtype = nd->rtype;
+                            nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            changed = 1;
+                            break;
+                    }
+                } else if (IRO_IsConstantNegativeOne(right)) {
+                    switch (nd->nodetype) {
+                        case EMUL:
+                        case EMULV:
+                        case EDIV:
+                            ReplaceExprWithMonaminLeft(nd);
+                            changed = 1;
+                            break;
+                        case EMODULO:
+                            ReplaceExprWithConst(nd, cint64_zero);
+                            changed = 1;
+                            break;
+                        case EMODASS:
+                            nd->nodetype = EASS;
+                            ReplaceExprWithConst(right, cint64_zero);
+                            nd->u.diadic.right->rtype = nd->rtype;
+                            nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            changed = 1;
+                            break;
+                    }
+                }
+            }
+
+            if (!changed && (IRO_IsIntConstant(left) || IRO_IsFloatConstant(left))) {
+                if (IRO_IsConstantZero(left)) {
+                    switch (nd->nodetype) {
+                        case EADDV:
+                        case EADD:
+                        case EXOR:
+                        case EOR:
+                        case ELOR:
+                            ReplaceExprWithRightChild(nd);
+                            break;
+                        case EMUL:
+                        case ESHL:
+                        case ESHR:
+                        case EAND:
+                        case ELAND:
+                            ReplaceExprWithConst(nd, cint64_zero);
+                            break;
+                        case ESUBV:
+                        case ESUB:
+                            ReplaceExprWithMonaminRight(nd);
+                            break;
+                    }
+                } else if (nd->nodetype == ELAND) {
+                    ReplaceExprWithRightChild(nd);
+                } else if (nd->nodetype == ELOR) {
+                    ReplaceExprWithConst(nd, cint64_one);
+                } else if (IRO_IsConstantOne(left)) {
+                    switch (nd->nodetype) {
+                        case EMUL:
+                        case EMULV:
+                            ReplaceExprWithRightChild(nd);
+                            break;
+                    }
+                } else if (IRO_IsConstantNegativeOne(left)) {
+                    switch (nd->nodetype) {
+                        case EMUL:
+                        case EMULV:
+                            ReplaceExprWithMonaminRight(nd);
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void DoTransformations12(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+            return;
+
+        if (IRO_ExprsSameSemantically(left, right) && !IRO_HasSideEffect(left)) {
+            switch (nd->nodetype) {
+                case ESUBV:
+                case ESUB:
+                case ELESS:
+                case EGREATER:
+                case ENOTEQU:
+                case EXOR:
+                    ReplaceExprWithConst(nd, cint64_zero);
+                    break;
+                case ELESSEQU:
+                case EGREATEREQU:
+                case EEQU:
+                    ReplaceExprWithConst(nd, cint64_one);
+                    break;
+                case EAND:
+                case EOR:
+                case ELAND:
+                case ELOR:
+                case EASS:
+                case EANDASS:
+                case EORASS:
+                    ReplaceExprWithLeftChild(nd);
+                    break;
+                case ESUBASS:
+                case EXORASS:
+                    nd->nodetype = EASS;
+                    ReplaceExprWithConst(right, cint64_zero);
+                    break;
+            }
+        }
+    }
+}
+
+static void DoTransformations13(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+    IROLinear *left2;
+    IROLinear *right2;
+    IROListNode *tmp;
+    IROListNode *leftlist;
+    IROListNode *rightlist;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+
+        if (
+            !IRO_HasSideEffect(left) &&
+            !IRO_HasSideEffect(right) &&
+            (nd->nodetype == EEQU || nd->nodetype == ENOTEQU) &&
+            PointerAnalysis_IsLinearNodePointerExprDefinite(FunctionName, left) &&
+            PointerAnalysis_IsLinearNodePointerExprDefinite(FunctionName, right)
+            )
+        {
+            leftlist = NULL;
+            PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, left, &leftlist);
+            if (leftlist) {
+                if (leftlist->list.head && leftlist->list.tail && !leftlist->nextList) {
+                    rightlist = NULL;
+                    PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, right, &rightlist);
+                    if (rightlist) {
+                        if (rightlist->list.head && rightlist->list.tail && !rightlist->nextList) {
+                            left2 = leftlist->list.tail;
+                            right2 = rightlist->list.tail;
+                            if (IRO_ExprsSameSemantically(left2, right2)) {
+                                ReplaceExprWithConst(nd, (nd->nodetype == EEQU) ? cint64_one : cint64_zero);
+                            } else if (left2->type == right2->type && IRO_TypesEqual(left2->rtype, right2->rtype)) {
+                                ReplaceExprWithConst(nd, (nd->nodetype == EEQU) ? cint64_zero : cint64_one);
+                            }
+                        }
+
+                        while (rightlist) {
+                            tmp = rightlist->nextList;
+                            IRO_free(rightlist);
+                            rightlist = tmp;
+                        }
+                    }
+                }
+
+                while (leftlist) {
+                    tmp = leftlist->nextList;
+                    IRO_free(leftlist);
+                    leftlist = tmp;
+                }
+            }
+        }
+    }
+}
+
+static void DoTransformations21(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+    Boolean changed;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+
+        if (left->type == IROLinearOp1Arg && right->type == IROLinearOp1Arg && left->nodetype == right->nodetype) {
+            switch (left->nodetype) {
+                case EMONMIN:
+                case EBINNOT:
+                case ELOGNOT:
+                    changed = 0;
+                    switch (nd->nodetype) {
+                        case EXOR:
+                            if (left->nodetype == EBINNOT)
+                                goto collapse;
+                            break;
+                        case ELESS:
+                        case EGREATER:
+                        case ELESSEQU:
+                        case EGREATEREQU:
+                            if (left->nodetype == EMONMIN) {
+                                nd->nodetype = ComplementaryOp[nd->nodetype];
+                                goto collapse;
+                            }
+                            break;
+                        case EMUL:
+                        case EDIV:
+                            if (left->nodetype == EMONMIN)
+                                goto collapse;
+                            break;
+                        case EEQU:
+                        case ENOTEQU:
+                            if (left->nodetype != ELOGNOT) {
+                            collapse:
+                                nd->u.diadic.left = left->u.monadic;
+                                nd->u.diadic.right = right->u.monadic;
+                                left->type = right->type = IROLinearNop;
+                                changed = 1;
+                            }
+                            break;
+                        case ELAND:
+                        case ELOR:
+                            if (left->nodetype == ELOGNOT) {
+                                nd->nodetype = ComplementaryOp[nd->nodetype];
+                                goto switchfather;
+                            }
+                            break;
+                        case EAND:
+                        case EOR:
+                            if (
+                                !IS_TYPE_FLOAT(nd->rtype) &&
+                                !IS_TYPE_FLOAT(left->rtype) &&
+                                !IS_TYPE_FLOAT(right->rtype) &&
+                                left->nodetype != EMONMIN
+                                )
+                            {
+                                nd->nodetype = ComplementaryOp[nd->nodetype];
+                                goto switchfather;
+                            }
+                            break;
+                        case EADD:
+                        case ESUB:
+                            if (
+                                !IS_TYPE_FLOAT(nd->rtype) &&
+                                !IS_TYPE_FLOAT(left->rtype) &&
+                                !IS_TYPE_FLOAT(right->rtype) &&
+                                left->nodetype == EMONMIN
+                                )
+                            {
+                            switchfather:
+                                switchFatherLeftMonadic(nd);
+                                nd->u.diadic.right = right->u.monadic;
+                                right->type = IROLinearNop;
+                                changed = 1;
+                            }
+                            break;
+                    }
+
+                    if (changed) {
+                        DoTransformations(nd);
+                        DoTransformations11(nd);
+                        DoTransformations12(nd);
+                        DoTransformations13(nd);
+                    }
+                    break;
+            }
+        }
+    }
+}
+
+static void DoTransformations22(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+    IROLinear *ndtmp;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+            return;
+
+        if (!IRO_HasSideEffect(left) && !IRO_HasSideEffect(right)) {
+            if (left->type == IROLinearOp1Arg && left->nodetype == EMONMIN) {
+                switch (nd->nodetype) {
+                    case ESUB:
+                    case ESUBV:
+                        nd->nodetype = ComplementaryOp[nd->nodetype];
+                        switchFatherLeftMonadic(nd);
+                        break;
+
+                    case EADD:
+                    case EADDV:
+                        nd->nodetype = ComplementaryOp[nd->nodetype];
+                        nd->u.diadic.left = right;
+                        nd->u.diadic.right = left->u.monadic;
+                        left->type = IROLinearNop;
+                        DoTransformations(nd);
+                        DoTransformations12(nd);
+                        DoTransformations21(nd);
+                        break;
+
+                    case EDIV:
+                        if (IRO_ExprsSameSemantically(left->u.monadic, right))
+                            ReplaceExprWithConst(nd, cint64_negone);
+                        break;
+                }
+            } else {
+                ndtmp = NULL;
+                if (left->type == IROLinearOp1Arg && IRO_ExprsSameSemantically(left->u.monadic, right))
+                    ndtmp = left;
+                else if (right->type == IROLinearOp1Arg && IRO_ExprsSameSemantically(left, right->u.monadic))
+                    ndtmp = right;
+
+                if (ndtmp) {
+                    switch (nd->nodetype) {
+                        case EAND:
+                            if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT)
+                                ReplaceExprWithConst(nd, cint64_zero);
+                            break;
+
+                        case EANDASS:
+                            if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT) {
+                                nd->nodetype = EASS;
+                                ReplaceExprWithConst(right, cint64_zero);
+                                nd->u.diadic.right->rtype = nd->rtype;
+                                nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            }
+                            break;
+
+                        case EXOR:
+                        case EOR:
+                            if (ndtmp->nodetype == EBINNOT) {
+                                ReplaceExprWithConst(nd, cint64_zero);
+                                nd->u.node->data.intval = CInt64_Inv(nd->u.node->data.intval);
+                            }
+                            break;
+
+                        case EXORASS:
+                        case EORASS:
+                            if (ndtmp->nodetype == EBINNOT) {
+                                nd->nodetype = EASS;
+                                ReplaceExprWithConst(right, cint64_zero);
+                                right->u.node->data.intval = CInt64_Inv(right->u.node->data.intval);
+                                nd->u.diadic.right->rtype = nd->rtype;
+                                nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            }
+                            break;
+
+                        case ELOR:
+                            if (ndtmp->nodetype == EBINNOT || ndtmp->nodetype == ELOGNOT)
+                                ReplaceExprWithConst(nd, cint64_one);
+                            break;
+
+                        case ELAND:
+                            if (ndtmp->nodetype == ELOGNOT)
+                                ReplaceExprWithConst(nd, cint64_zero);
+                            break;
+
+                        case EDIV:
+                            if (ndtmp->nodetype == EMONMIN)
+                                ReplaceExprWithConst(nd, cint64_negone);
+                            break;
+
+                        case EDIVASS:
+                            if (ndtmp->nodetype == EMONMIN) {
+                                nd->nodetype = EASS;
+                                ReplaceExprWithConst(right, cint64_negone);
+                                nd->u.diadic.right->rtype = nd->rtype;
+                                nd->u.diadic.right->u.node->rtype = nd->rtype;
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void DoTransformations23(IROLinear *nd) {
+    Boolean changed;
+    Boolean isCompare;
+    UInt8 which;
+    IROLinear *left;
+    IROLinear *right;
+    CInt64 size;
+    CInt64 val;
+
+    if (nd->type == IROLinearOp2Arg && !IRO_HasSideEffect(nd)) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+            return;
+
+        isCompare = 0;
+        changed = 0;
+        which = 0;
+
+        switch (nd->nodetype) {
+            case ELESS:
+            case EGREATER:
+            case ELESSEQU:
+            case EGREATEREQU:
+                isCompare = 1;
+            case EADDV:
+            case EADD:
+            case EEQU:
+            case ENOTEQU:
+            case EAND:
+            case EOR:
+                if (left->type == IROLinearOp2Arg) {
+                    if (IRO_ExprsSameSemantically(right, left->u.diadic.left))
+                        which = 1;
+                    else if (IRO_ExprsSameSemantically(right, left->u.diadic.right))
+                        which = 2;
+
+                    if (which) {
+                        if (isCompare)
+                            nd->nodetype = ComplementaryOp[nd->nodetype];
+                        IRO_SwitchChildren(nd);
+                        left = nd->u.diadic.left;
+                        right = nd->u.diadic.right;
+                        break;
+                    }
+                }
+            case ESUBV:
+            case ESUB:
+            case EADDASS:
+            case ESUBASS:
+            case EANDASS:
+            case EORASS:
+                if (right->type == IROLinearOp2Arg) {
+                    if (IRO_ExprsSameSemantically(left, right->u.diadic.left))
+                        which = 1;
+                    else if (IRO_ExprsSameSemantically(left, right->u.diadic.right))
+                        which = 2;
+                }
+                break;
+
+            default:
+                goto done;
+        }
+
+        if (which) {
+            switch (right->nodetype) {
+                case EAND:
+                case EOR:
+                    if (which == 2)
+                        IRO_SwitchChildren(right);
+
+                    if (
+                        nd->nodetype == right->nodetype ||
+                        (nd->nodetype == EANDASS && right->nodetype == EAND) ||
+                        (nd->nodetype == EORASS && right->nodetype == EOR)
+                        )
+                    {
+                        ReplaceExprWithRightChild(right);
+                        changed = 1;
+                    }
+                    else if (
+                        nd->nodetype == ComplementaryOp[right->nodetype] ||
+                        (nd->nodetype == EANDASS && right->nodetype == EOR) ||
+                        (nd->nodetype == EORASS && right->nodetype == EAND)
+                        )
+                    {
+                        ReplaceExprWithLeftChild(nd);
+                    }
+                    break;
+
+                case EADD:
+                    if (which == 2)
+                        IRO_SwitchChildren(right);
+
+                    switch (nd->nodetype) {
+                        case EEQU:
+                        case ENOTEQU:
+                            ReplaceExprWithConst(left, cint64_zero);
+                            ReplaceExprWithRightChild(right);
+                            IRO_SwitchChildren(nd);
+                            if (isCompare)
+                                nd->nodetype = ComplementaryOp[nd->nodetype];
+                            changed = 1;
+                            break;
+
+                        case ESUB:
+                        case ESUBV:
+                            ReplaceExprWithRightChild(right);
+                            ReplaceExprWithMonaminRight(nd);
+                            changed = 1;
+                            break;
+
+                        case ESUBASS:
+                            ReplaceExprWithRightChild(right);
+                            changed = 1;
+                            break;
+                    }
+                    break;
+
+                case ESUB:
+                    switch (nd->nodetype) {
+                        case EEQU:
+                        case ENOTEQU:
+                            if (which == 1) {
+                                ReplaceExprWithConst(left, cint64_zero);
+                                ReplaceExprWithRightChild(right);
+                                IRO_SwitchChildren(nd);
+                            }
+                            break;
+                        case EADD:
+                        case EADDV:
+                            if (which == 2) {
+                                ReplaceExprWithLeftChild(right);
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                        case ESUB:
+                        case ESUBV:
+                            if (which == 1) {
+                                ReplaceExprWithRightChild(right);
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                        case EADDASS:
+                            if (which == 2) {
+                                nd->nodetype = EASS;
+                                ReplaceExprWithLeftChild(right);
+                                changed = 1;
+                            }
+                            break;
+                        case ESUBASS:
+                            if (which == 1) {
+                                nd->nodetype = EASS;
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+                    }
+                    break;
+            }
+        }
+
+    done:
+        if (!changed) {
+            switch (nd->nodetype) {
+                case ESUB:
+                case ESUBV:
+                    which = 0;
+                    if (left->type == IROLinearOp2Arg) {
+                        if (IRO_ExprsSameSemantically(right, left->u.diadic.left))
+                            which = 1;
+                        else if (IRO_ExprsSameSemantically(right, left->u.diadic.right))
+                            which = 2;
+                    }
+
+                    if (which == 1) {
+                        if (left->nodetype == ESUB) {
+                            ReplaceExprWithMonaminRight(left);
+                            ReplaceExprWithLeftChild(nd);
+                        } else if (left->nodetype == EADD) {
+                            ReplaceExprWithRightChild(left);
+                            ReplaceExprWithLeftChild(nd);
+                        }
+                    } else if (which == 2) {
+                        if (left->nodetype == EADD) {
+                            ReplaceExprWithLeftChild(left);
+                            ReplaceExprWithLeftChild(nd);
+                        }
+                    }
+                    break;
+            }
+
+            switch (nd->nodetype) {
+                case ESHL:
+                case ESHR:
+                case ESHLASS:
+                case ESHRASS:
+                    which = 0;
+                    if (left->type == IROLinearOp2Arg) {
+                        if (left->nodetype == ComplementaryOp[nd->nodetype] || left->nodetype == AssignmentOp[ComplementaryOp[nd->nodetype]]) {
+                            if (IRO_IsIntConstant(right) && IRO_ExprsSameSemantically(right, left->u.diadic.right))
+                                which = 2;
+                        }
+                    }
+
+                    if (which == 2) {
+                        val = right->u.node->data.intval;
+                        if (left->nodetype == ESHR || left->nodetype == ESHRASS) {
+                            ReplaceExprWithLeftChild(left);
+                            nd->nodetype = (nd->nodetype == ESHL) ? EAND : EANDASS;
+                            right->u.node->data.intval = CInt64_Shl(cint64_negone, val);
+                            changed = 1;
+                        } else if (IRO_IsUnsignedType(nd->rtype)) {
+                            ReplaceExprWithLeftChild(left);
+                            nd->nodetype = (nd->nodetype == ESHR) ? EAND : EANDASS;
+                            if (nd->rtype->size < 8) {
+                                CInt64_SetLong(&size, 64 - 8 * nd->rtype->size);
+                                val = CInt64_Add(val, size);
+                            }
+                            right->u.node->data.intval = CInt64_ShrU(cint64_negone, val);
+                            changed = 1;
+                        }
+                    }
+                    break;
+            }
+        }
+
+        if (changed) {
+            DoTransformations(nd);
+            DoTransformations11(nd);
+            DoTransformations12(nd);
+            DoTransformations13(nd);
+            DoTransformations21(nd);
+            DoTransformations22(nd);
+            DoTransformations23(nd);
+        }
+    }
+}
+
+static void DoTransformations24(IROLinear *nd) {
+    IROLinear *left;
+    IROLinear *right;
+    UInt8 changed;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        if (IS_TYPE_FLOAT(nd->rtype) || IS_TYPE_FLOAT(left->rtype) || IS_TYPE_FLOAT(right->rtype))
+            return;
+
+        if (left->type == IROLinearOp2Arg && right->type == IROLinearOp2Arg && !IRO_HasSideEffect(nd)) {
+            changed = 0;
+
+            if (IRO_ExprsSameSemantically(left->u.diadic.left, right->u.diadic.left)) {
+                if (left->nodetype == right->nodetype) {
+                    switch (left->nodetype) {
+                        case EADD:
+                            if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                ReplaceExprWithRightChild(left);
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+                        case ESUB:
+                            if (nd->nodetype == ESUB || nd->nodetype == ESUBV) {
+                                ReplaceExprWithRightChild(left);
+                                ReplaceExprWithRightChild(right);
+                                IRO_SwitchChildren(nd);
+                                changed = 1;
+                            }
+                            break;
+                        case EMUL:
+                            switch (nd->nodetype) {
+                                case EADD:
+                                case ESUB:
+                                    PickCommonsubAtLeftLeft(nd);
+                                    changed = 3;
+                                    break;
+                            }
+                            break;
+                        case EAND:
+                            if (nd->nodetype == EXOR) {
+                                PickCommonsubAtLeftLeft(nd);
+                                changed = 3;
+                                break;
+                            }
+                        case EOR:
+                            if (nd->nodetype == left->nodetype) {
+                                ReplaceExprWithRightChild(left);
+                                changed = 1;
+                            } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                PickCommonsubAtLeftLeft(nd);
+                                changed = 3;
+                            }
+                            break;
+                    }
+                } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+                    switch (nd->nodetype) {
+                        case ESUB:
+                        case ESUBV:
+                            switch (left->nodetype) {
+                                case EADD:
+                                    nd->nodetype = ComplementaryOp[nd->nodetype];
+                                    ReplaceExprWithRightChild(left);
+                                    ReplaceExprWithRightChild(right);
+                                    changed = 1;
+                                    break;
+                                case ESUB:
+                                    ReplaceExprWithMonaminRight(left);
+                                    ReplaceExprWithRightChild(right);
+                                    changed = 1;
+                                    break;
+                            }
+                            break;
+
+                        case EAND:
+                        case EOR:
+                            if (left->nodetype == nd->nodetype)
+                                ReplaceExprWithLeftChild(nd);
+                            else if (right->nodetype == nd->nodetype)
+                                ReplaceExprWithRightChild(nd);
+                            break;
+                    }
+                }
+            } else if (IRO_ExprsSameSemantically(left->u.diadic.right, right->u.diadic.left)) {
+                if (left->nodetype == right->nodetype) {
+                    switch (left->nodetype) {
+                        case EADD:
+                            if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                ReplaceExprWithLeftChild(left);
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+                        case EMUL:
+                            switch (nd->nodetype) {
+                                case EADD:
+                                case ESUB:
+                                    PickCommonsubAtRightLeft(nd);
+                                    changed = 3;
+                                    break;
+                            }
+                            break;
+                        case EAND:
+                            if (nd->nodetype == EXOR) {
+                                PickCommonsubAtRightLeft(nd);
+                                changed = 3;
+                                break;
+                            }
+                        case EOR:
+                            if (nd->nodetype == left->nodetype) {
+                                ReplaceExprWithLeftChild(left);
+                                changed = 1;
+                            } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                PickCommonsubAtRightLeft(nd);
+                                changed = 3;
+                            }
+                            break;
+                    }
+                } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+                    switch (nd->nodetype) {
+                        case ESUB:
+                        case ESUBV:
+                            if (left->nodetype == EADD) {
+                                nd->nodetype = ComplementaryOp[nd->nodetype];
+                                ReplaceExprWithLeftChild(left);
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+
+                        case EADD:
+                        case EADDV:
+                            if (left->nodetype == ESUB) {
+                                ReplaceExprWithLeftChild(left);
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+
+                        case EAND:
+                        case EOR:
+                            if (left->nodetype == nd->nodetype)
+                                ReplaceExprWithLeftChild(nd);
+                            else if (right->nodetype == nd->nodetype)
+                                ReplaceExprWithRightChild(nd);
+                            break;
+                    }
+                }
+            } else if (IRO_ExprsSameSemantically(left->u.diadic.left, right->u.diadic.right)) {
+                if (left->nodetype == right->nodetype) {
+                    switch (left->nodetype) {
+                        case EADD:
+                            if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                ReplaceExprWithRightChild(left);
+                                ReplaceExprWithLeftChild(right);
+                                changed = 1;
+                            }
+                            break;
+                        case ESUB:
+                            switch (nd->nodetype) {
+                                case EADDV:
+                                case EADD:
+                                    nd->nodetype = ComplementaryOp[nd->nodetype];
+                                    ReplaceExprWithRightChild(left);
+                                    ReplaceExprWithLeftChild(right);
+                                    IRO_SwitchChildren(nd);
+                                    changed = 1;
+                                    break;
+                            }
+                            break;
+                        case EMUL:
+                            switch (nd->nodetype) {
+                                case EADD:
+                                case ESUB:
+                                    PickCommonsubAtLeftRight(nd);
+                                    changed = 2;
+                                    break;
+                            }
+                            break;
+                        case EAND:
+                            if (nd->nodetype == EXOR) {
+                                PickCommonsubAtLeftRight(nd);
+                                changed = 2;
+                                break;
+                            }
+                        case EOR:
+                            if (nd->nodetype == left->nodetype) {
+                                ReplaceExprWithRightChild(left);
+                                changed = 1;
+                            } else if (nd->nodetype == ComplementaryOp[left->nodetype]) {
+                                PickCommonsubAtLeftRight(nd);
+                                changed = 2;
+                            }
+                            break;
+                    }
+                } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+                    switch (nd->nodetype) {
+                        case EADD:
+                        case EADDV:
+                            if (left->nodetype == EADD) {
+                                ReplaceExprWithRightChild(left);
+                                ReplaceExprWithLeftChild(right);
+                                changed = 1;
+                            }
+                            break;
+
+                        case ESUB:
+                        case ESUBV:
+                            if (left->nodetype == ESUB) {
+                                ReplaceExprWithMonaminRight(left);
+                                ReplaceExprWithRightChild(right);
+                                changed = 1;
+                            }
+                            break;
+
+                        case EAND:
+                        case EOR:
+                            if (left->nodetype == nd->nodetype)
+                                ReplaceExprWithLeftChild(nd);
+                            else if (right->nodetype == nd->nodetype)
+                                ReplaceExprWithRightChild(nd);
+                            break;
+                    }
+                }
+            } else if (IRO_ExprsSameSemantically(left->u.diadic.right, right->u.diadic.right)) {
+                if (left->nodetype == right->nodetype) {
+                    switch (nd->nodetype) {
+                        case ESUB:
+                            switch (left->nodetype) {
+                                case EADD:
+                                case ESUB:
+                                    ReplaceExprWithLeftChild(left);
+                                    ReplaceExprWithLeftChild(right);
+                                    changed = 1;
+                            }
+                        case EADD:
+                            switch (left->nodetype) {
+                                case EMUL:
+                                case ESHL:
+                                    PickCommonsubAtRightRight(nd);
+                                    changed = 2;
+                                    break;
+                            }
+                            break;
+                        case EXOR:
+                            switch (left->nodetype) {
+                                case ESHL:
+                                case ESHR:
+                                case EAND:
+                                    PickCommonsubAtRightRight(nd);
+                                    changed = 2;
+                                    break;
+                            }
+                            break;
+                        case EAND:
+                        case EOR:
+                            if (left->nodetype == nd->nodetype) {
+                                ReplaceExprWithLeftChild(right);
+                                changed = 1;
+                            } else if (
+                                left->nodetype == ComplementaryOp[nd->nodetype] ||
+                                left->nodetype == ESHR ||
+                                left->nodetype == ESHL
+                                )
+                            {
+                                PickCommonsubAtRightRight(nd);
+                                changed = 2;
+                            }
+                            break;
+                    }
+                } else if (left->nodetype == ComplementaryOp[right->nodetype]) {
+                    switch (nd->nodetype) {
+                        case EADD:
+                        case EADDV:
+                            switch (left->nodetype) {
+                                case EADD:
+                                case ESUB:
+                                    ReplaceExprWithLeftChild(left);
+                                    ReplaceExprWithLeftChild(right);
+                                    changed = 1;
+                                    break;
+                            }
+                            break;
+
+                        case EAND:
+                        case EOR:
+                            if (left->nodetype == nd->nodetype)
+                                ReplaceExprWithLeftChild(nd);
+                            else if (right->nodetype == nd->nodetype)
+                                ReplaceExprWithRightChild(nd);
+                            break;
+                    }
+                }
+            }
+
+            if (changed) {
+                DoDiadic(nd);
+                if (changed == 2)
+                    DoDiadic(nd->u.diadic.left);
+                else if (changed == 3)
+                    DoDiadic(nd->u.diadic.right);
+                IRO_Dump("remove common op at: %d\n", nd->index);
+            }
+        }
+    }
+}
+
+static void DoTransformations25(IROLinear *nd) {
+    int changed = 0;
+    IROLinear *left;
+    IROLinear *right;
+
+    if (nd->type == IROLinearOp2Arg) {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+
+        if (
+            (left->type == IROLinearOp2Arg && (IS_TYPE_FLOAT(left->u.diadic.left->rtype) || IS_TYPE_FLOAT(left->u.diadic.right->rtype))) ||
+            (right->type == IROLinearOp2Arg && (IS_TYPE_FLOAT(right->u.diadic.left->rtype) || IS_TYPE_FLOAT(right->u.diadic.right->rtype)))
+            )
+            return;
+
+        switch (left->nodetype) {
+            case ELESS:
+            case EGREATER:
+            case ELESSEQU:
+            case EGREATEREQU:
+            case EEQU:
+            case ENOTEQU:
+                switch (nd->nodetype) {
+                    case EEQU:
+                        if (IRO_IsConstantOne(right)) {
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        } else if (IRO_IsConstantZero(right)) {
+                            left->nodetype = ComplementaryOpLogical[left->nodetype];
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        }
+                        break;
+                    case ENOTEQU:
+                        if (IRO_IsConstantOne(right)) {
+                            left->nodetype = ComplementaryOpLogical[left->nodetype];
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        } else if (IRO_IsConstantZero(right)) {
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        }
+                        break;
+                }
+                break;
+            case ELAND:
+            case ELOR:
+                switch (nd->nodetype) {
+                    case EEQU:
+                        if (IRO_IsConstantOne(right)) {
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        }
+                        break;
+                    case ENOTEQU:
+                        if (IRO_IsConstantZero(right)) {
+                            ReplaceExprWithLeftChild(nd);
+                            changed = 1;
+                        }
+                        break;
+                }
+                break;
+        }
+
+        if (!changed) {
+            switch (right->nodetype) {
+                case ELESS:
+                case EGREATER:
+                case ELESSEQU:
+                case EGREATEREQU:
+                case EEQU:
+                case ENOTEQU:
+                    switch (nd->nodetype) {
+                        case EEQU:
+                            if (IRO_IsConstantOne(left)) {
+                                ReplaceExprWithRightChild(nd);
+                            } else if (IRO_IsConstantZero(left)) {
+                                right->nodetype = ComplementaryOpLogical[right->nodetype];
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                        case ENOTEQU:
+                            if (IRO_IsConstantOne(left)) {
+                                right->nodetype = ComplementaryOpLogical[right->nodetype];
+                                ReplaceExprWithRightChild(nd);
+                            } else if (IRO_IsConstantZero(left)) {
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                    }
+                    break;
+                case ELAND:
+                case ELOR:
+                    switch (nd->nodetype) {
+                        case EEQU:
+                            if (IRO_IsConstantOne(left)) {
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                        case ENOTEQU:
+                            if (IRO_IsConstantZero(left)) {
+                                ReplaceExprWithRightChild(nd);
+                            }
+                            break;
+                    }
+                    break;
+            }
+        }
+    }
+}
+
+static Boolean isOrderingOperator(ENodeType op) {
+    switch (op) {
+        case ELAND:
+        case ELOR:
+        case ECOMMA:
+        case ECOND:
+        case ECONDASS:
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+static void RemoveUnreffed(IROLinear *nd) {
+    if (!(nd->flags & IROLF_Reffed)) {
+        switch (nd->type) {
+            case IROLinearOperand:
+                IRO_NopNonSideEffects(nd, 0);
+                break;
+            case IROLinearOp1Arg:
+            case IROLinearOp2Arg:
+            case IROLinearOp3Arg:
+            case IROLinearFunccall:
+                if (!isOrderingOperator(nd->nodetype))
+                    IRO_NopNonSideEffects(nd, 0);
+                break;
+        }
+    }
+}
+
+static void RemoveRedundantMonadicOp(IROLinear *nd) {
+    IROLinear *nd2;
+    IROLinear *nd3;
+
+    if (nd->type == IROLinearOp1Arg && (nd2 = IRO_LocateFather(nd)) && nd2->nodetype == nd->nodetype) {
+        switch (nd->nodetype) {
+            case ELOGNOT:
+                if ((nd3 = IRO_LocateFather(nd2))) {
+                    if (
+                        nd3->rtype &&
+                        TYPE_INTEGRAL(nd3->rtype)->integral == IT_BOOL &&
+                        nd->u.monadic->rtype &&
+                        TYPE_INTEGRAL(nd->u.monadic->rtype)->integral == IT_BOOL
+                        )
+                        goto remove;
+
+                    if (nd3->type == IROLinearIf)
+                        goto remove;
+                    if (nd3->type == IROLinearIfNot)
+                        goto remove;
+                    if (nd3->type == IROLinearOp3Arg && nd == nd3->u.args3.a)
+                        goto remove;
+
+                    switch (nd3->nodetype) {
+                        case ELOGNOT:
+                        case ELAND:
+                        case ELOR:
+                            goto remove;
+                    }
+                }
+
+                if (nd->u.monadic->type == IROLinearOp1Arg || nd->u.monadic->type == IROLinearOp2Arg) {
+                    switch (nd->u.monadic->nodetype) {
+                        case ELOGNOT:
+                        case ELESS:
+                        case EGREATER:
+                        case ELESSEQU:
+                        case EGREATEREQU:
+                        case EEQU:
+                        case ENOTEQU:
+                        case ELAND:
+                        case ELOR:
+                            goto remove;
+                    }
+                }
+                break;
+
+            case EMONMIN:
+            case EBINNOT:
+            remove:
+                IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd2, nd->u.monadic);
+                nd2->type = IROLinearNop;
+                nd->type = IROLinearNop;
+                break;
+
+            case ETYPCON:
+                if (TYPE_INTEGRAL(nd->rtype)->integral == IT_FLOAT) {
+                    switch (TYPE_INTEGRAL(nd2->rtype)->integral) {
+                        case IT_DOUBLE:
+                        case IT_LONGDOUBLE:
+                            switch (TYPE_INTEGRAL(nd->u.monadic->rtype)->integral) {
+                                case IT_BOOL:
+                                case IT_CHAR:
+                                case IT_SCHAR:
+                                case IT_UCHAR:
+                                case IT_SHORT:
+                                case IT_USHORT:
+                                    nd->type = IROLinearNop;
+                                    nd2->u.monadic = nd->u.monadic;
+                                    break;
+                            }
+                            break;
+                    }
+                }
+                break;
+        }
+    }
+}
+
+static void ReverseOpForMonmin(IROLinear *nd) {
+    IROLinear *father;
+
+    if (
+        nd->type == IROLinearOp1Arg &&
+        nd->nodetype == EMONMIN &&
+        (father = IRO_LocateFather(nd)) &&
+        father->type == IROLinearOp2Arg &&
+        father->u.diadic.right == nd
+        )
+    {
+        switch (father->nodetype) {
+            case EADDV:
+            case ESUBV:
+            case EADD:
+            case ESUB:
+            case EADDASS:
+            case ESUBASS:
+                father->nodetype = ComplementaryOp[father->nodetype];
+                nd->type = IROLinearNop;
+                father->u.diadic.right = nd->u.monadic;
+                break;
+        }
+    }
+}
+
+static void DoDiadic(IROLinear *nd) {
+    RemoveUnreffed(nd);
+    DoTransformations(nd);
+    DoTransformations11(nd);
+    DoTransformations12(nd);
+    DoTransformations13(nd);
+    DoTransformations21(nd);
+    DoTransformations22(nd);
+    DoTransformations23(nd);
+    DoTransformations24(nd);
+    DoTransformations25(nd);
+}
+
+void IRO_DoTransformations(void) {
+    IROLinear *nd;
+
+    for (nd = IRO_FirstLinear; nd; nd = nd->next) {
+        switch (nd->type) {
+            case IROLinearOp2Arg:
+                DoDiadic(nd);
+                break;
+            case IROLinearOp1Arg:
+                RemoveUnreffed(nd);
+                RemoveRedundantMonadicOp(nd);
+                ReverseOpForMonmin(nd);
+                break;
+            case IROLinearOperand:
+                RemoveUnreffed(nd);
+                break;
+        }
+    }
+
+    IRO_CheckForUserBreak();
+}
+
+static Boolean ReconcileAssignments(IROLinear *nd1, IROLinear *nd2, IROList *list) {
+    IROLinear *copy;
+    Boolean result = 0;
+    int argCount;
+    int i;
+    IROLinear *tmp;
+
+    if (
+        (nd2->type == IROLinearOp1Arg && nd2->nodetype == ETYPCON) &&
+        !(nd1->type == IROLinearOp1Arg && nd1->nodetype == ETYPCON) &&
+        ReconcileAssignments(nd1, nd2->u.monadic, list)
+        )
+    {
+        result = 1;
+    }
+
+    if (
+        (nd1->type == IROLinearOp1Arg && nd1->nodetype == ETYPCON) &&
+        !(nd2->type == IROLinearOp1Arg && nd2->nodetype == ETYPCON) &&
+        ReconcileAssignments(nd1->u.monadic, nd2, list)
+        )
+    {
+        copy = IRO_NewLinear(IROLinearOp1Arg);
+        *copy = *nd2;
+        copy->index = IRO_NumLinear++;
+        copy->type = IROLinearOp1Arg;
+        copy->nodetype = ETYPCON;
+        copy->rtype = nd1->rtype;
+        copy->next = NULL;
+        copy->u.monadic = list->tail;
+        IRO_AddToList(copy, list);
+        result = 1;
+    }
+
+    if (nd1->type == nd2->type && nd1->nodetype == nd2->nodetype) {
+        copy = IRO_NewLinear(IROLinearNop);
+        *copy = *nd2;
+        copy->index = IRO_NumLinear++;
+        copy->rtype = nd1->rtype;
+        copy->next = NULL;
+        switch (nd1->type) {
+            case IROLinearOperand:
+                if (nd1->u.node->type == nd2->u.node->type) {
+                    if (!(nd1->u.node->type == EOBJREF && nd1->u.node->data.objref != nd2->u.node->data.objref))
+                        result = 1;
+                }
+                break;
+
+            case IROLinearOp1Arg:
+                if (ReconcileAssignments(nd1->u.monadic, nd2->u.monadic, list)) {
+                    copy->u.monadic = list->tail;
+                    result = 1;
+                }
+                break;
+
+            case IROLinearOp2Arg:
+                tmp = list->tail;
+                if (ReconcileAssignments(nd1->u.diadic.left, nd2->u.diadic.left, list)) {
+                    copy->u.diadic.left = list->tail;
+                    if (ReconcileAssignments(nd1->u.diadic.right, nd2->u.diadic.right, list)) {
+                        copy->u.diadic.right = list->tail;
+                        result = 1;
+                    }
+                }
+
+                if (!result && !IRO_HasSideEffect(nd1) && !IRO_HasSideEffect(nd2)) {
+                    if (nd1->nodetype == EMUL || nd1->nodetype == EADD || nd1->nodetype == EAND || nd1->nodetype == EXOR || nd1->nodetype == EOR) {
+                        list->tail = tmp;
+                        if (ReconcileAssignments(nd1->u.diadic.left, nd2->u.diadic.right, list)) {
+                            copy->u.diadic.right = list->tail;
+                            if (ReconcileAssignments(nd1->u.diadic.right, nd2->u.diadic.left, list)) {
+                                copy->u.diadic.left = list->tail;
+                                result = 1;
+                            }
+                        }
+                    }
+                }
+                break;
+
+            case IROLinearOp3Arg:
+                if (ReconcileAssignments(nd1->u.args3.c, nd2->u.args3.c, list)) {
+                    copy->u.args3.c = list->tail;
+                    if (ReconcileAssignments(nd1->u.args3.b, nd2->u.args3.b, list)) {
+                        copy->u.args3.b = list->tail;
+                        if (ReconcileAssignments(nd1->u.args3.a, nd2->u.args3.a, list)) {
+                            copy->u.args3.a = list->tail;
+                            result = 1;
+                        }
+                    }
+                }
+                break;
+
+            case IROLinearFunccall:
+                argCount = nd1->u.funccall.argCount;
+                if (argCount == nd2->u.funccall.argCount) {
+                    result = 1;
+                    copy->u.funccall.args = oalloc(sizeof(IROLinear *) * argCount);
+                    for (i = argCount - 1; i >= 0; i--) {
+                        if (!ReconcileAssignments(nd1->u.funccall.args[i], nd2->u.funccall.args[i], list)) {
+                            result = 0;
+                            break;
+                        }
+                        copy->u.funccall.args[i] = list->tail;
+                    }
+
+                    if (result) {
+                        if (!ReconcileAssignments(nd1->u.funccall.linear8, nd2->u.funccall.linear8, list)) {
+                            result = 0;
+                            break;
+                        }
+                        copy->u.funccall.linear8 = list->tail;
+                    }
+                }
+                break;
+        }
+
+        if (result)
+            IRO_AddToList(copy, list);
+    }
+
+    return result;
+}
+
+static IROLinear *FrontendTransformSelfAssignmentToAssignment(IROLinear *nd) {
+    Statement *stmt;
+    IROList list;
+    IROLinearIRSave save;
+
+    IRO_SaveLinearIR(&save);
+
+    IRO_InitList(&list);
+    IRO_DuplicateExpr(nd, &list);
+
+    stmt = IRO_Delinearize(NULL, list.head);
+    CError_ASSERT(3550, stmt);
+    CError_ASSERT(3552, stmt->expr);
+    stmt->expr = CIRTrans_TransformOpAss(stmt->expr);
+    CError_ASSERT(3557, stmt->expr);
+
+    if (DoLinearize)
+        IRO_PreLinearize(stmt);
+    IRO_Linearize(stmt);
+
+    IRO_InitList(&list);
+    list.head = IRO_FirstLinear;
+    list.tail = IRO_LastLinear;
+
+    IRO_RestoreLinearIR(&save);
+
+    for (nd = list.head; nd; nd = nd->next) {
+        if (!(nd->flags & IROLF_Reffed) && IRO_IsAssignment(nd))
+            break;
+    }
+
+    return nd;
+}
+
+static Type *PromotedIntegralType(Type *type) {
+    CError_ASSERT(3586, IS_TYPE_ENUM(type) || IS_TYPE_INT(type));
+
+    if (IS_TYPE_ENUM(type))
+        type = TYPE_ENUM(type)->enumtype;
+
+    if (TYPE_INTEGRAL(type)->integral < IT_INT) {
+        if (IRO_IsUnsignedType(type))
+            return TYPE(&stunsignedint);
+        else
+            return TYPE(&stsignedint);
+    } else {
+        return type;
+    }
+}
+
+static Boolean TransformMonadicSelfAssignmentToDiadicSelfAssignment(IROLinear *nd) {
+    ENodeType t;
+    ENodeType newtype;
+    IROLinear *incExpr;
+    IROLinear *varExpr;
+
+    t = nd->nodetype;
+
+    if (IRO_IsAssignment(nd) && IRO_IsModifyOp[t]) {
+        incExpr = NULL;
+        varExpr = NULL;
+        newtype = MAXEXPR;
+
+        if (
+            nd->type == IROLinearOp1Arg &&
+            (t == EPOSTINC || t == EPOSTDEC || t == EPREINC || t == EPREDEC) &&
+            (!(nd->flags & IROLF_Reffed) || t == EPREINC || t == EPREDEC)
+            )
+        {
+            Type *type = nd->rtype;
+            TypeType typetype = type->type;
+            varExpr = nd->u.monadic;
+            if (typetype == TYPEINT || typetype == TYPEENUM) {
+                incExpr = IRO_NewIntConst(cint64_one, PromotedIntegralType(type));
+            } else if (typetype == TYPEPOINTER || typetype == TYPEARRAY || typetype == TYPEMEMBERPOINTER) {
+                Type *inner = NULL;
+                CInt64 val = cint64_zero;
+
+                if (typetype == TYPEPOINTER || typetype == TYPEARRAY)
+                    inner = TPTR_TARGET(type);
+                else if (typetype == TYPEMEMBERPOINTER)
+                    inner = TYPE_MEMBER_POINTER(type)->ty1;
+
+                if (inner)
+                    CInt64_SetLong(&val, inner->size);
+
+                if (!CInt64_IsZero(&val)) {
+                    incExpr = IRO_NewIntConst(val, TYPE(&stsignedlong));
+                } else {
+                    return 0;
+                }
+            } else if (typetype == TYPEFLOAT) {
+                Float fval;
+                fval = CMach_CalcFloatConvertFromInt(type, cint64_one);
+                incExpr = IRO_NewFloatConst(fval, nd->rtype);
+            } else {
+                return 0;
+            }
+
+            if (t == EPOSTINC || t == EPREINC)
+                newtype = EADDASS;
+            else
+                newtype = ESUBASS;
+        }
+
+        if (
+            varExpr &&
+            incExpr &&
+            newtype != MAXEXPR &&
+            varExpr->u.diadic.left &&
+            varExpr->u.diadic.left->type == IROLinearOperand &&
+            varExpr->u.diadic.left->u.node &&
+            varExpr->u.diadic.left->u.node->type == EOBJREF &&
+            !IRO_HasSideEffect(varExpr)
+            )
+        {
+            incExpr->flags |= IROLF_Reffed;
+            nd->nodetype = newtype;
+            nd->u.diadic.right = incExpr;
+            nd->type = IROLinearOp2Arg;
+            IRO_Paste(incExpr, incExpr, nd);
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+Boolean IRO_TransformSelfAssignmentToAssignment(IROLinear *nd) {
+    ENodeType nonAssOp;
+    IROLinear *left;
+    IROLinear *right;
+    ENodeType nodetype;
+    IROLinear *nonAss;
+    IROLinear *dupLeft;
+    IROLinear *last;
+    IROList list1;
+    IROList list2;
+
+    nodetype = nd->nodetype;
+    if (
+        IRO_IsAssignment(nd) &&
+        IRO_IsModifyOp[nodetype] &&
+        nd->type == IROLinearOp1Arg &&
+        TransformMonadicSelfAssignmentToDiadicSelfAssignment(nd)
+        )
+        nodetype = nd->nodetype;
+
+    if (
+        IRO_IsAssignment(nd) &&
+        IRO_IsModifyOp[nodetype] &&
+        nd->type == IROLinearOp2Arg &&
+        IRO_NonAssignmentOp[nodetype] != MAXEXPR
+        )
+    {
+        left = nd->u.diadic.left;
+        right = nd->u.diadic.right;
+        nonAssOp = IRO_NonAssignmentOp[nodetype];
+        if (
+            left &&
+            right &&
+            nonAssOp != MAXEXPR &&
+            left->u.monadic &&
+            left->u.monadic->type == IROLinearOperand &&
+            left->u.monadic->u.node &&
+            left->u.monadic->u.node->type == EOBJREF &&
+            !IRO_HasSideEffect(left)
+            )
+        {
+            IRO_InitList(&list1);
+            dupLeft = IRO_DuplicateExpr(left, &list1);
+
+            if (left->rtype != right->rtype) {
+                IROLinear *tmp = IRO_NewLinear(IROLinearOp1Arg);
+                tmp->nodetype = ETYPCON;
+                tmp->flags |= IROLF_Reffed;
+                tmp->rtype = right->rtype;
+                tmp->index = ++IRO_NumLinear;
+                tmp->u.monadic = dupLeft;
+                IRO_AddToList(tmp, &list1);
+                dupLeft = tmp;
+            }
+
+            nonAss = IRO_NewLinear(IROLinearOp2Arg);
+            nonAss->nodetype = nonAssOp;
+            nonAss->flags |= IROLF_Reffed;
+            nonAss->rtype = dupLeft->rtype;
+            nonAss->index = ++IRO_NumLinear;
+            nonAss->u.diadic.left = dupLeft;
+            nonAss->u.diadic.right = right;
+            IRO_AddToList(nonAss, &list1);
+
+            if (left->rtype != right->rtype) {
+                IROLinear *tmp = IRO_NewLinear(IROLinearOp1Arg);
+                tmp->nodetype = ETYPCON;
+                tmp->flags |= IROLF_Reffed;
+                tmp->rtype = left->rtype;
+                tmp->index = ++IRO_NumLinear;
+                tmp->u.monadic = nonAss;
+                IRO_AddToList(tmp, &list1);
+                nonAss = tmp;
+            }
+
+            IRO_InitList(&list2);
+            last = FrontendTransformSelfAssignmentToAssignment(nd);
+            if (
+                last &&
+                last->type == IROLinearOp2Arg &&
+                ReconcileAssignments(last->u.diadic.right, nonAss, &list2)
+                )
+            {
+                IRO_NopOut(nd->u.diadic.right);
+                nd->nodetype = EASS;
+                nd->u.diadic.right = list2.tail;
+                nd->type = IROLinearOp2Arg;
+                IRO_Paste(list2.head, list2.tail, nd);
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+static void AddAddend(ENode *expr) {
+    if (expr->type == EADD) {
+        AddAddend(expr->data.diadic.left);
+        AddAddend(expr->data.diadic.right);
+    } else {
+        ENodeList *list = oalloc(sizeof(ENodeList));
+        list->node = expr;
+        list->next = NULL;
+
+        if (FirstAddend)
+            LastAddend->next = list;
+        else
+            FirstAddend = list;
+        LastAddend = list;
+    }
+}
+
+static ENode *CombineConstants(ENode *expr) {
+    ENode *addend;
+    ENodeList *el;
+    ENode *result;
+    ENode *var;
+    Type *type;
+    ENode *tmp;
+    ENodeList *prev;
+    CInt64 val;
+
+    FirstAddend = LastAddend = NULL;
+    AddAddend(expr->data.diadic.left);
+    AddAddend(expr->data.diadic.right);
+
+    // these variable names are courtesy of the resource fork in abort_exit.c
+    el = FirstAddend;
+    prev = NULL;
+    var = NULL;
+    while (el) {
+        addend = el->node;
+        if (addend->type == EOBJREF) {
+            var = addend;
+            if (prev)
+                prev->next = el->next;
+            else
+                FirstAddend = el->next;
+            break;
+        }
+        prev = el;
+        el = el->next;
+    }
+
+    if (!var) {
+        el = FirstAddend;
+        prev = NULL;
+        while (el) {
+            addend = el->node;
+            if (addend->type == EINDIRECT) {
+                var = addend;
+                if (prev)
+                    prev->next = el->next;
+                else
+                    FirstAddend = el->next;
+                break;
+            }
+            prev = el;
+            el = el->next;
+        }
+    }
+
+    prev = NULL;
+    CInt64_SetLong(&val, 0);
+    type = NULL;
+
+    for (el = FirstAddend; el; el = el->next) {
+        addend = el->node;
+        if (addend->type == EINTCONST && addend->rtype) {
+            if (!type || type->size < addend->rtype->size)
+                type = addend->rtype;
+            val = CInt64_Add(val, addend->data.intval);
+            if (prev)
+                prev->next = el->next;
+            else
+                FirstAddend = el->next;
+        } else if (addend->type == EMUL && addend->data.diadic.right->type == EINTCONST && addend->rtype) {
+            if (!type || type->size < addend->rtype->size)
+                type = addend->rtype;
+
+            tmp = addend->data.diadic.left;
+            if (tmp->type == EADD && tmp->data.diadic.right->type == EINTCONST) {
+                val = CInt64_Add(val, CInt64_MulU(tmp->data.diadic.right->data.intval, addend->data.diadic.right->data.intval));
+                addend->data.diadic.left = tmp->data.diadic.left;
+            }
+            prev = el;
+        } else {
+            prev = el;
+        }
+    }
+
+    result = NULL;
+    if (var) {
+        result = var;
+        if (!CInt64_IsZero(&val)) {
+            result = IRO_NewENode(EADD);
+            result->data.diadic.left = var;
+            result->data.diadic.right = IRO_NewENode(EINTCONST);
+            result->data.diadic.right->data.intval = val;
+            result->data.diadic.right->rtype = type;
+            result->rtype = var->rtype;
+            result->cost = 1;
+            CInt64_SetLong(&val, 0);
+        }
+    }
+
+    for (el = FirstAddend; el; el = el->next) {
+        addend = el->node;
+        if (result) {
+            tmp = IRO_NewENode(EADD);
+            tmp->data.diadic.left = result;
+            tmp->data.diadic.right = addend;
+            tmp->cost = result->cost + 1;
+            tmp->rtype = result->rtype;
+            result = tmp;
+        } else {
+            result = addend;
+        }
+    }
+
+    if (!CInt64_IsZero(&val)) {
+        tmp = IRO_NewENode(EADD);
+        tmp->data.diadic.left = result;
+        tmp->data.diadic.right = IRO_NewENode(EINTCONST);
+        tmp->data.diadic.right->data.intval = val;
+        tmp->data.diadic.right->rtype = type;
+        tmp->cost = result->cost + 1;
+        tmp->rtype = result->rtype;
+        result = tmp;
+    }
+
+    return result;
+}
+
+static ENode *TransformExprNode(ENode *expr) {
+    ENode *left;
+    ENode *right;
+
+    switch (expr->type) {
+        case EINDIRECT:
+            if (ENODE_IS(expr->data.monadic, EADD))
+                expr->data.monadic = CombineConstants(expr->data.monadic);
+            break;
+
+        case EMUL:
+        case EADD:
+        case EAND:
+        case EXOR:
+        case EOR:
+            if (
+                IS_TYPE_INT(expr->rtype) &&
+                !ENODE_IS(right = expr->data.diadic.right, EINTCONST) &&
+                ENODE_IS(left = expr->data.diadic.left, EINTCONST)
+                )
+            {
+                expr->data.diadic.left = right;
+                expr->data.diadic.right = left;
+            }
+            break;
+
+        case EEQU:
+        case ENOTEQU:
+            if (
+                IS_TYPE_INT(expr->rtype) &&
+                !ENODE_IS(left = expr->data.diadic.right, EINTCONST) &&
+                ENODE_IS(right = expr->data.diadic.left, EINTCONST)
+                )
+            {
+                expr->data.diadic.left = left;
+                expr->data.diadic.right = right;
+            }
+
+            if (
+                ENODE_IS(expr->data.diadic.right, EINTCONST) &&
+                ENODE_IS(left = expr->data.diadic.left, EBINNOT)
+                )
+            {
+                expr->data.diadic.left = left->data.monadic;
+                left->data.monadic = expr->data.diadic.right;
+                expr->data.diadic.right = left;
+            }
+
+            break;
+    }
+
+    return expr;
+}
+
+static ENode *TransformExprTree(ENode *expr) {
+    ENodeList *list;
+
+    switch (expr->type) {
+        ENODE_CASE_MONADIC:
+            expr->data.monadic = TransformExprTree(expr->data.monadic);
+            break;
+
+        ENODE_CASE_DIADIC_ALL:
+            expr->data.diadic.left = TransformExprTree(expr->data.diadic.left);
+            expr->data.diadic.right = TransformExprTree(expr->data.diadic.right);
+            break;
+
+        case EFUNCCALL:
+        case EFUNCCALLP:
+            TransformExprTree(expr->data.funccall.funcref);
+            for (list = expr->data.funccall.args; list; list = list->next)
+                TransformExprTree(list->node);
+            break;
+
+        case ECOND:
+            TransformExprTree(expr->data.cond.cond);
+            TransformExprTree(expr->data.cond.expr1);
+            TransformExprTree(expr->data.cond.expr2);
+            break;
+
+        case ENULLCHECK:
+            TransformExprTree(expr->data.nullcheck.nullcheckexpr);
+            TransformExprTree(expr->data.nullcheck.condexpr);
+            break;
+    }
+
+    return TransformExprNode(expr);
+}
+
+static void FoldConstantsinAssociativeExprs(ENode *expr) {
+    short nodetype1;
+    short nodetype2;
+    short nodetype3;
+    Boolean changed;
+    short op;
+    CInt64 val1;
+    CInt64 val2;
+    CInt64 tmpval;
+
+    if (
+        (
+            expr->type == EADD ||
+            expr->type == EMUL ||
+            expr->type == EAND ||
+            expr->type == EXOR ||
+            expr->type == EOR ||
+            expr->type == ESHL ||
+            expr->type == ESHR
+        ) &&
+        IS_TYPE_INT(expr->rtype) &&
+        expr->data.diadic.right->type == EINTCONST
+        )
+    {
+        do {
+            changed = 0;
+
+            if (
+                expr->data.diadic.left->type == expr->type &&
+                expr->data.diadic.left->data.diadic.right->type == EINTCONST
+                )
+            {
+                val1 = expr->data.diadic.right->data.intval;
+                val2 = expr->data.diadic.left->data.diadic.right->data.intval;
+                switch (expr->type) {
+                    case EADD:
+                    case ESHL:
+                        op = '+';
+                        break;
+                    case ESHR:
+                        op = '+';
+                        if (!IRO_IsUnsignedType(expr->rtype)) {
+                            CInt64_SetLong(&tmpval, expr->rtype->size * 8);
+                            if (CInt64_GreaterEqualU(val1, tmpval) || CInt64_GreaterEqualU(val2, tmpval))
+                                return;
+
+                            if (CInt64_GreaterEqualU(CMach_CalcIntDiadic(expr->rtype, val1, '+', val2), tmpval)) {
+                                val1 = CInt64_Sub(tmpval, cint64_one);
+                                val2 = cint64_zero;
+                            }
+                        }
+                        break;
+                    case EMUL:
+                        op = '*';
+                        break;
+                    case EAND:
+                        op = '&';
+                        break;
+                    case EOR:
+                        op = '|';
+                        break;
+                    case EXOR:
+                        op = '^';
+                        break;
+                    default:
+                        return;
+                }
+
+                expr->data.diadic.right->data.intval = CMach_CalcIntDiadic(expr->rtype, val1, op, val2);
+                expr->data.diadic.left = expr->data.diadic.left->data.diadic.left;
+                changed = 1;
+            } else if (
+                ((nodetype1 = expr->type) == EAND || nodetype1 == EOR) &&
+                ((nodetype2 = expr->data.diadic.left->type) == EAND || nodetype2 == EOR) &&
+                ((nodetype3 = expr->data.diadic.left->data.diadic.left->type) == EAND || nodetype3 == EOR) &&
+                expr->data.diadic.left->data.diadic.left->data.diadic.right->type == EINTCONST
+                )
+            {
+                val1 = expr->data.diadic.right->data.intval;
+                if (CInt64_Equal(val1, expr->data.diadic.left->data.diadic.left->data.diadic.right->data.intval)) {
+                    if (nodetype1 == nodetype3) {
+                        expr->data.diadic.left->data.diadic.left = expr->data.diadic.left->data.diadic.left->data.diadic.left;
+                        changed = 1;
+                    } else if (nodetype2 == nodetype3) {
+                        *expr = *expr->data.diadic.right;
+                        changed = 1;
+                    } else {
+                        expr->data.diadic.left = expr->data.diadic.left->data.diadic.right;
+                        changed = 1;
+                    }
+                }
+            }
+        } while (changed);
+    }
+}
+
+static void TransformExprTree1(ENode *expr) {
+    ENodeList *list;
+
+    switch (expr->type) {
+        ENODE_CASE_MONADIC:
+            TransformExprTree1(expr->data.monadic);
+            break;
+
+        ENODE_CASE_DIADIC_ALL:
+            TransformExprTree1(expr->data.diadic.left);
+            TransformExprTree1(expr->data.diadic.right);
+            break;
+
+        case EFUNCCALL:
+        case EFUNCCALLP:
+            TransformExprTree1(expr->data.funccall.funcref);
+            for (list = expr->data.funccall.args; list; list = list->next)
+                TransformExprTree1(list->node);
+            break;
+
+        case ECOND:
+            TransformExprTree1(expr->data.cond.cond);
+            TransformExprTree1(expr->data.cond.expr1);
+            TransformExprTree1(expr->data.cond.expr2);
+            break;
+
+        case ENULLCHECK:
+            TransformExprTree1(expr->data.nullcheck.nullcheckexpr);
+            TransformExprTree1(expr->data.nullcheck.condexpr);
+            break;
+    }
+
+    FoldConstantsinAssociativeExprs(expr);
+}
+
+static int RemoveRedundantBitOperations(ENode *expr) {
+    Boolean a;
+    Boolean b;
+
+    if (expr->type == ExprType) {
+        a = RemoveRedundantBitOperations(expr->data.diadic.left);
+        b = RemoveRedundantBitOperations(expr->data.diadic.right);
+        return a & b;
+    }
+
+    if (expr->type == EINDIRECT) {
+        if (expr->data.monadic->type == EOBJREF) {
+            if (!OperandObject) {
+                OperandObject = expr->data.monadic->data.objref;
+                IndirectRef = expr;
+                return 1;
+            } else {
+                return expr->data.monadic->data.objref == OperandObject;
+            }
+        } else {
+            return 0;
+        }
+    }
+
+    if (expr->type == EINTCONST) {
+        if (FirstTime) {
+            OperandConst = expr->data.intval;
+            FirstTime = 0;
+        } else if (ExprType == EAND) {
+            OperandConst = CInt64_And(expr->data.intval, OperandConst);
+        } else if (ExprType == EOR) {
+            OperandConst = CInt64_Or(expr->data.intval, OperandConst);
+        } else if (ExprType == EXOR) {
+            OperandConst = CInt64_Xor(expr->data.intval, OperandConst);
+        }
+        return 1;
+    }
+
+    return 0;
+}
+
+static void TransformExprTree2(ENode *expr) {
+    ENodeList *list;
+
+    switch (expr->type) {
+        ENODE_CASE_MONADIC:
+            TransformExprTree2(expr->data.monadic);
+            break;
+
+        ENODE_CASE_DIADIC_ALL:
+            TransformExprTree2(expr->data.diadic.left);
+            TransformExprTree2(expr->data.diadic.right);
+            break;
+
+        case EFUNCCALL:
+        case EFUNCCALLP:
+            TransformExprTree2(expr->data.funccall.funcref);
+            for (list = expr->data.funccall.args; list; list = list->next)
+                TransformExprTree2(list->node);
+            break;
+
+        case ECOND:
+            TransformExprTree2(expr->data.cond.cond);
+            TransformExprTree2(expr->data.cond.expr1);
+            TransformExprTree2(expr->data.cond.expr2);
+            break;
+
+        case ENULLCHECK:
+            TransformExprTree2(expr->data.nullcheck.nullcheckexpr);
+            TransformExprTree2(expr->data.nullcheck.condexpr);
+            break;
+    }
+
+    if (
+        ENODE_IS3(expr, EAND, EOR, EXOR) &&
+        (expr->type == expr->data.diadic.left->type || expr->type == expr->data.diadic.right->type)
+        )
+    {
+        OperandObject = NULL;
+        ExprType = expr->type;
+        FirstTime = 1;
+        IndirectRef = NULL;
+
+        if (RemoveRedundantBitOperations(expr)) {
+            expr->data.diadic.left = IndirectRef;
+            expr->data.diadic.right->type = EINTCONST;
+            expr->data.diadic.right->data.intval = OperandConst;
+        }
+    }
+}
+
+static void PullOutPostOps(Statement *stmt, ENode **pExpr) {
+    ENode *ind;
+    ENode *inner;
+    Statement *newStmt;
+
+    switch ((*pExpr)->type) {
+        ENODE_CASE_MONADIC:
+            if ((*pExpr)->type != EFORCELOAD)
+                PullOutPostOps(stmt, &(*pExpr)->data.monadic);
+
+            if (ENODE_IS2(*pExpr, EPOSTINC, EPOSTDEC)) {
+                inner = (*pExpr)->data.monadic;
+                if (
+                    ENODE_IS(inner, EINDIRECT) &&
+                    inner->rtype &&
+                    !CParser_IsVolatile(inner->rtype, ENODE_QUALS(inner)) &&
+                    ENODE_IS(inner->data.monadic, EOBJREF) &&
+                    !is_volatile_object(inner->data.monadic->data.objref)
+                    )
+                {
+                    newStmt = lalloc(sizeof(Statement));
+                    memset(newStmt, 0, sizeof(Statement));
+                    newStmt->type = ST_EXPRESSION;
+                    newStmt->expr = *pExpr;
+                    newStmt->dobjstack = stmt->dobjstack;
+                    newStmt->sourceoffset = stmt->sourceoffset;
+                    newStmt->sourcefilepath = stmt->sourcefilepath;
+                    newStmt->value = stmt->value;
+                    newStmt->flags = stmt->flags;
+                    newStmt->next = stmt->next;
+                    stmt->next = newStmt;
+
+                    ind = IRO_NewENode(EINDIRECT);
+                    *ind = *inner;
+                    ind->data.monadic = IRO_NewENode(EOBJREF);
+                    *ind->data.monadic = *inner->data.monadic;
+                    *pExpr = ind;
+                }
+            }
+            break;
+
+        ENODE_CASE_DIADIC_ALL:
+            if (ENODE_IS(*pExpr, ECOND))
+                break;
+            if (ENODE_IS(*pExpr, ECOMMA))
+                break;
+            if (ENODE_IS(*pExpr, ELOR))
+                break;
+            if (ENODE_IS(*pExpr, ELAND))
+                break;
+            if (ENODE_IS(*pExpr, ENULLCHECK))
+                break;
+            PullOutPostOps(stmt, &(*pExpr)->data.diadic.left);
+            PullOutPostOps(stmt, &(*pExpr)->data.diadic.right);
+            break;
+    }
+}
+
+void IRO_TransformTree(Statement *statements) {
+    Statement *stmt;
+    Statement *next;
+
+    for (stmt = statements; stmt; stmt = next) {
+        next = stmt->next;
+        switch (stmt->type) {
+            case ST_EXPRESSION:
+            case ST_SWITCH:
+            case ST_IFGOTO:
+            case ST_IFNGOTO:
+            case ST_RETURN:
+                if (stmt->expr) {
+                    stmt->expr = TransformExprTree(stmt->expr);
+                    TransformExprTree2(stmt->expr);
+                    TransformExprTree1(stmt->expr);
+                }
+                break;
+        }
+    }
+
+    IRO_CheckForUserBreak();
+}
diff --git a/compiler_and_linker/unsorted/IroUnrollLoop.c b/compiler_and_linker/unsorted/IroUnrollLoop.c
index f5c4fb0..5bbe490 100644
--- a/compiler_and_linker/unsorted/IroUnrollLoop.c
+++ b/compiler_and_linker/unsorted/IroUnrollLoop.c
@@ -1,8 +1,38 @@
 #include "compiler/IroUnrollLoop.h"
+#include "compiler/CError.h"
+#include "compiler/IroFlowgraph.h"
+#include "compiler/IroLinearForm.h"
 #include "compiler/IroUtil.h"
+#include "compiler/LoopDetection.h"
+#include "compiler/IroLoop.h"
+#include "compiler/IroDump.h"
+#include "compiler/IroVars.h"
+#include "compiler/CFunc.h"
+#include "compiler/CMachine.h"
+
+#ifdef __MWERKS__
+#pragma options align=mac68k
+#endif
+typedef struct LoopList {
+    UInt8 flags;
+    BitVector *bv;
+    struct LoopList *next;
+    IRONode *fnode;
+    int xE;
+} LoopList;
+#ifdef __MWERKS__
+#pragma options align=reset
+#endif
 
 // forward decls
 static void IRO_FindLoops_Unroll(void);
+static void LoopUnroll(int count, IRONode *fnode);
+static int IsLoopUnrollable(IROLoop *loop);
+static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval);
+static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop);
+static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list);
+static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);
+static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop);
 
 void IRO_LoopUnroller(void) {
     VectorPhaseCalledFromUnroll = 1;
@@ -11,85 +41,2265 @@ void IRO_LoopUnroller(void) {
 }
 
 static void IRO_FindLoops_Unroll(void) {
+    IRONode *fnode;
+    IRONode *pred;
+    UInt16 i;
+    UInt16 flag;
+    LoopList *list;
+    LoopList *list2;
+
+    fnode = IRO_FirstNode;
+    LoopList_First = NULL;
+
+    while (fnode) {
+        flag = 0;
+        for (i = 0; i < fnode->numpred; i++) {
+            pred = IRO_NodeTable[fnode->pred[i]];
+            if (Bv_IsBitSet(fnode->index, pred->dom)) {
+                if (!flag) {
+                    Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
+                    Bv_Clear(InLoop);
+                    Bv_SetBit(fnode->index, InLoop);
+                }
+                flag = 1;
+                Bv_SetBit(pred->index, InLoop);
+                if (pred != fnode)
+                    AddPreds(pred);
+            }
+        }
+
+        if (flag) {
+            if (!LoopList_First) {
+                list = oalloc(sizeof(LoopList));
+                list->next = NULL;
+            } else {
+                list = oalloc(sizeof(LoopList));
+                list->next = LoopList_First;
+            }
+            LoopList_First = list;
+
+            Bv_AllocVector(&list->bv, IRO_NumNodes + 1);
+            list->flags |= 1;
+            Bv_Copy(InLoop, list->bv);
+            list->fnode = fnode;
+            list->xE = 0;
+        }
+
+        fnode = fnode->nextnode;
+    }
+
+    list = LoopList_First;
+    Bv_AllocVector(&LoopTemp, IRO_NumNodes + 1);
+    while (list) {
+        for (list2 = LoopList_First; list2; list2 = list2->next) {
+            if (list2 != list) {
+                IRO_Dump(" header = %d \n", list2->fnode->index);
+                IRO_Dump(" l1 bit vector=\n");
+                IRO_DumpBits("", list2->bv);
+                IRO_Dump(" l bit vector=\n");
+                IRO_DumpBits("", list->bv);
+                if (Bv_IsSubset(list->bv, list2->bv))
+                    list2->flags &= ~1;
+            }
+        }
+        list = list->next;
+    }
+
+    for (list = LoopList_First; list; list = list->next) {
+        if (list->flags & 1) {
+            IRONode *listfnode;
+            Bv_Copy(list->bv, InLoop);
+            listfnode = list->fnode;
+            IRO_Dump("IRO_FindLoops_Unroll:Found loop with header %d\n", listfnode->index);
+            IRO_DumpBits("Loop includes: ", InLoop);
+            LoopUnroll(copts.loop_unroll_count, listfnode);
+            IRO_UpdateFlagsOnInts();
+        }
+    }
 }
 
-static void CheckConstant() {
+static int CheckConstant(CInt64 a, CInt64 b, CInt64 *result) {
+    CInt64 shl = cint64_zero;
+    CInt64 work = cint64_zero;
+    CInt64 and = cint64_zero;
+    CInt64 i;
+
+    for (i = cint64_zero; CInt64_Less(i, a); i = CInt64_Add(i, cint64_one)) {
+        shl = CInt64_Shl(b, i);
+        and = CInt64_And(shl, work);
+        if (CInt64_NotEqual(and, cint64_zero))
+            return 0;
+        work = CInt64_Or(shl, work);
+    }
+
+    *result = work;
+    return 1;
 }
 
-static void UnrollWhileLoopBody() {
+typedef struct LoopPattern {
+    IROLinear *nd0;
+    IROLinear *nd4;
+    Type *type;
+    IROLinear *ndC;
+    IROLinear *nd10;
+    CInt64 val14;
+    CInt64 val1C;
+} LoopPattern;
+
+static void UnrollWhileLoopBody(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, LoopPattern *pattern, UInt32 unrollFactor) {
+    IRONode *scan;
+    int pass;
+    IROLinear *firstnode;
+    IROLinear *lastnd;
+    IROLinear *nd;
+    IROLinear *nd1;
+    IROLinear *nd2;
+    IROLinear *nd3;
+    IROLinear *nd4;
+    IROLinear *nd5;
+    IROLinear *nd6;
+    IROLinear *nd8;
+    IROLinear *nd7;
+    ENode *expr;
+    IROList list;
+    CInt64 zero;
+    CInt64 shiftval;
+
+    CInt64_SetLong(&zero, 0);
+
+    pass = 0;
+
+    do {
+        firstnode = NULL;
+        for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
+            IRO_InitList(&list);
+            lastnd = scan->last;
+            nd = scan->first;
+            while (1) {
+                if (nd->stmt)
+                    nd->stmt->flags |= StmtFlag_10;
+
+                if (
+                    (nd->index < loop->index20 || nd->index > loop->index24) &&
+                    nd->type != IROLinearLabel &&
+                    nd->type != IROLinearNop &&
+                    !(nd->flags & IROLF_Reffed)
+                    )
+                {
+                    CError_ASSERT(345, nd->nodetype == EORASS || nd->nodetype == EANDASS || nd->nodetype == EXORASS);
+
+                    IRO_DuplicateExpr(pattern->nd0, &list);
+                    nd1 = list.tail;
+
+                    shiftval = cint64_one;
+                    shiftval = CInt64_Shl(shiftval, pattern->val1C);
+
+                    nd2 = IRO_NewLinear(IROLinearOperand);
+                    nd2->index = ++IRO_NumLinear;
+                    nd2->rtype = pattern->nd0->rtype;
+                    expr = IRO_NewENode(EINTCONST);
+                    expr->rtype = pattern->nd0->rtype;
+                    CInt64_SetLong(&expr->data.intval, pass * CInt64_GetULong(&shiftval));
+                    nd2->u.node = expr;
+                    IRO_AddToList(nd2, &list);
+
+                    IRO_DuplicateExpr(pattern->nd4, &list);
+
+                    nd3 = IRO_NewLinear(IROLinearOp2Arg);
+                    nd3->index = ++IRO_NumLinear;
+                    nd3->nodetype = EADD;
+                    nd3->rtype = pattern->type;
+                    nd3->u.diadic.left = list.tail;
+                    nd3->u.diadic.right = nd2;
+                    IRO_AddToList(nd3, &list);
+
+                    nd4 = IRO_NewLinear(IROLinearOp2Arg);
+                    nd4->index = ++IRO_NumLinear;
+                    nd4->nodetype = EADD;
+                    nd4->rtype = pattern->type;
+                    nd4->u.diadic.left = nd3;
+                    nd4->u.diadic.right = nd1;
+                    IRO_AddToList(nd4, &list);
+
+                    nd5 = IRO_NewLinear(IROLinearOp1Arg);
+                    nd5->index = ++IRO_NumLinear;
+                    nd5->nodetype = EINDIRECT;
+                    nd5->rtype = nd->rtype;
+                    nd5->u.monadic = nd4;
+                    IRO_AddToList(nd5, &list);
+
+                    nd6 = IRO_NewLinear(IROLinearOp2Arg);
+                    *nd6 = *nd;
+                    nd6->index = ++IRO_NumLinear;
+                    nd6->u.diadic.left = list.tail;
+                    nd6->next = NULL;
+
+                    nd7 = IRO_NewLinear(IROLinearOperand);
+                    nd7->index = ++IRO_NumLinear;
+                    nd7->rtype = pattern->ndC->rtype;
+                    expr = IRO_NewENode(EINTCONST);
+                    expr->rtype = pattern->ndC->rtype;
+                    nd7->u.node = expr;
+                    nd7->next = NULL;
+                    expr->data.intval = pattern->val14;
+
+                    if (
+                        IS_LINEAR_DIADIC(nd, EANDASS) &&
+                        CInt64_Equal(pattern->val14, cint64_zero)
+                        )
+                    {
+                        nd6->nodetype = EASS;
+                    } else if (
+                        IS_LINEAR_DIADIC(nd, EORASS) &&
+                        !CTool_EndianReadWord32(&pattern->val14.hi)
+                        )
+                    {
+                        UInt32 tmp = CInt64_GetULong(&pattern->val14);
+                        if (
+                            (nd->rtype->size == 1 && tmp == 0xFF) ||
+                            (nd->rtype->size == 2 && tmp == 0xFFFF) ||
+                            (nd->rtype->size == 4 && tmp == 0xFFFFFFFF)
+                            )
+                        {
+                            nd6->nodetype = EASS;
+                        }
+                    }
+
+                    IRO_AddToList(nd7, &list);
+
+                    if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
+                        nd8 = IRO_NewLinear(IROLinearOp1Arg);
+                        *nd8 = *pattern->nd10;
+                        nd8->index = ++IRO_NumLinear;
+                        nd8->u.monadic = nd7;
+                        nd8->next = NULL;
+                        IRO_AddToList(nd8, &list);
+                    } else {
+                        nd8 = nd7;
+                    }
+                    nd6->u.diadic.right = nd8;
+                    IRO_AddToList(nd6, &list);
+
+                    if (!firstnode)
+                        firstnode = list.head;
+                }
+
+                if (nd == lastnd)
+                    break;
+                nd = nd->next;
+            }
+
+            if (list.head && list.tail)
+                IRO_Paste(list.head, list.tail, fnode2->last);
+        }
+    } while (++pass < 8);
 }
 
-static void PatternMatchLoop() {
+static int PatternMatchLoop(IRONode *fnode, IROLoop *loop, IROLoopInd *ind, UInt32 *unrollFactor, SInt32 *result1, SInt32 *result2, LoopPattern *pattern) {
+    IROLinear *scan;
+    IROLinear *varnode;
+    IROLinear *nd1;
+    IROLinear *nd2;
+    IROLinear *left1;
+    IROLinear *left2;
+    IROLinear *right1;
+    IROLinear *right2;
+    Object *obj1;
+    Object *obj2;
+    CInt64 shl;
+    CInt64 val;
+
+    *result1 = 0;
+    *result2 = 0;
+
+    if ((scan = fnode->first)) {
+        while (1) {
+            if (
+                (scan->index < loop->index20 || scan->index > loop->index24) &&
+                !(scan->flags & IROLF_Reffed) &&
+                scan->type != IROLinearNop &&
+                scan->type != IROLinearLabel
+                )
+            {
+                if (IS_LINEAR_DIADIC_3(scan, EORASS, EXORASS, EANDASS)) {
+                    (*result2)++;
+                    if (IS_LINEAR_MONADIC(scan->u.diadic.left, EINDIRECT)) {
+                        varnode = scan->u.diadic.left->u.monadic;
+                        if (IS_LINEAR_DIADIC(varnode, EADD)) {
+                            pattern->nd4 = varnode->u.diadic.left;
+                            pattern->type = varnode->rtype;
+                            if (IRO_IsVariable(varnode->u.diadic.left)) {
+                                pattern->nd0 = varnode->u.diadic.right;
+                                if (
+                                    IS_LINEAR_DIADIC(pattern->nd0, ESHL) &&
+                                    IRO_IsConstant(pattern->nd0->u.diadic.right)
+                                    )
+                                {
+                                    pattern->val1C = pattern->nd0->u.diadic.right->u.node->data.intval;
+                                    nd1 = pattern->nd0->u.diadic.left;
+                                } else {
+                                    return 0;
+                                }
+                            } else {
+                                return 0;
+                            }
+                        } else {
+                            return 0;
+                        }
+                    } else {
+                        return 0;
+                    }
+
+                    pattern->nd10 = scan->u.diadic.right;
+
+                    if (IS_LINEAR_MONADIC(pattern->nd10, ETYPCON)) {
+                        if (IS_LINEAR_DIADIC(scan, EANDASS)) {
+                            if (IS_LINEAR_MONADIC(pattern->nd10->u.monadic, EBINNOT)) {
+                                pattern->ndC = pattern->nd10->u.monadic->u.monadic;
+                            } else {
+                                return 0;
+                            }
+                        } else {
+                            pattern->ndC = pattern->nd10->u.monadic;
+                        }
+
+                        if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
+                            nd2 = pattern->ndC->u.diadic.right;
+                        } else {
+                            return 0;
+                        }
+                    } else if (IS_LINEAR_DIADIC(pattern->nd10, ESHL) && IS_LINEAR_DIADIC_2(scan, EORASS, EXORASS)) {
+                        pattern->ndC = pattern->nd10;
+                        if (IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
+                            nd2 = pattern->ndC->u.diadic.right;
+                        } else {
+                            return 0;
+                        }
+                    } else if (IS_LINEAR_MONADIC(pattern->nd10, EBINNOT) && IS_LINEAR_DIADIC(scan, EANDASS)) {
+                        pattern->ndC = pattern->nd10->u.monadic;
+                        if (IS_LINEAR_DIADIC(pattern->ndC, ESHL) && IRO_IsConstant(pattern->ndC->u.diadic.left)) {
+                            val = pattern->ndC->u.diadic.left->u.node->data.intval;
+                            nd2 = pattern->ndC->u.diadic.right;
+                        } else {
+                            return 0;
+                        }
+                    } else {
+                        return 0;
+                    }
+
+                    if (IS_LINEAR_DIADIC(nd2, EAND) && IS_LINEAR_DIADIC(nd1, ESHR)) {
+                        left1 = nd1->u.diadic.left;
+                        left2 = nd2->u.diadic.left;
+                        obj1 = IRO_IsVariable(left1);
+                        obj2 = IRO_IsVariable(left2);
+                        if (obj1 == obj2 && obj1 == ind->var->object) {
+                            right1 = nd1->u.diadic.right;
+                            right2 = nd2->u.diadic.right;
+                            if (IRO_IsConstant(right1) && IRO_IsConstant(right2)) {
+                                shl = cint64_one;
+                                shl = CInt64_Shl(shl, right1->u.node->data.intval);
+                                shl = CInt64_Sub(shl, cint64_one);
+                                if (CInt64_Equal(shl, right2->u.node->data.intval)) {
+                                    if (CTool_EndianReadWord32(&shl.hi) == 0) {
+                                        *unrollFactor = CInt64_GetULong(&shl) + 1;
+                                        if (CheckConstant(CInt64_Add(shl, cint64_one), val, &pattern->val14)) {
+                                            (*result1)++;
+                                            if (IS_LINEAR_DIADIC(scan, EANDASS))
+                                                pattern->val14 = CInt64_Not(pattern->val14);
+                                        }
+                                    } else {
+                                        return 0;
+                                    }
+                                } else {
+                                    return 0;
+                                }
+                            } else {
+                                return 0;
+                            }
+                        } else {
+                            return 0;
+                        }
+                    } else {
+                        return 0;
+                    }
+                } else {
+                    return 0;
+                }
+            }
+
+            if (scan == fnode->last)
+                break;
+            scan = scan->next;
+        }
+    }
+
+    return 1;
 }
 
-static void UnrollWhileLoop() {
+static UInt32 UnrollWhileLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
+    IROLoopInd *ind;
+    IRONode *scan;
+    CLabel *lastlabel;
+    IROLinear *lastlabelnode;
+    IROLinear *earlyLoopExitTest;
+    CLabel *earlyLoopExitTestLabel;
+    IROLinear *origIterationCount;
+    IROLinear *unrolledFinalValue;
+    IROLinear *preAlignTemp;
+    IROLinear *newFinalValue;
+    IROLinear *savedHead60;
+    IROLinear *unrolledBodyEntryTest;
+    CLabel *label;
+    IROLinear *savedHead2;
+    IROLinear *loophead25;
+    IROLinear *loopend;
+    IROLinear *loopscan;
+    IROLinear *indvar;
+    IROLinear *less;
+    IROLinear *loopExitTest;
+    IROLinear *saveTail;
+    CLabel *label2;
+    IROLinear *gotond;
+    CLabel *label3;
+    IROLinear *savedHead3;
+    IROLinear *updIndInc;
+    IROLinear *label2nd;
+    IROLinear *less2;
+    IROLinear *saveTail2;
+    IROLinear *less3;
+    IROLinear *wtf;
+    IROLinear *constnd;
+    IROLinear *ass;
+    IROLinear *nd18;
+    IRONode *fn19;
+    IRONode *newfnode1;
+    IRONode *newfnode2;
+    IRONode *newfnode3;
+    IRONode *newfnode4;
+    IRONode *newfnode5;
+    IRONode *newfnode6;
+    IRONode *newfnode7;
+    IRONode *newfnode8;
+    IROLinear *lastnd;
+    ENode *expr;
+    SInt32 result1;
+    SInt32 result2;
+    LoopPattern pattern;
+    IROList list;
+
+    IRO_Dump("while(n--) loop \n");
+
+    if (loop->flags & LoopFlags_800) {
+        IRO_Dump("loop not unrolled because induction used in loop \n");
+        return 0;
+    }
+    if (loop->flags & LoopFlags_1000) {
+        IRO_Dump("loop not unrolled because loop has multiple exits \n");
+        return 0;
+    }
+
+    if (!(loop->flags & LP_HAS_MULTIPLE_INDUCTIONS))
+        return 0;
+
+    for (ind = FirstInd; ind; ind = ind->next) {
+        if ((ind->flags & LoopInd_HasMod) && (ind->flags & LoopInd_HasDiv))
+            break;
+    }
+
+    if (!ind) {
+        IRO_Dump("Could not find loop with and induction with MOD and DIV operation\n");
+        return 0;
+    }
+
+    if (!IRO_IsUnsignedType(ind->nd->rtype))
+        return 0;
+
+    if (ind->nd->type == IROLinearOp2Arg) {
+        if (ind->nd->nodetype == EADDASS && IRO_IsConstant(ind->nd->u.diadic.right)) {
+            if (ind->addConst != 1)
+                return 0;
+        } else if (ind->nd->nodetype == EASS) {
+            if (
+                ind->nd->u.diadic.right->type != IROLinearOp2Arg ||
+                ind->nd->u.diadic.right->nodetype != EADD ||
+                !IRO_IsConstant(ind->nd->u.diadic.right->u.diadic.right)
+                )
+                return 0;
+
+            if (ind->addConst != 1)
+                return 0;
+        } else {
+            return 0;
+        }
+    } else if (ind->nd->type == IROLinearOp1Arg && ind->nd->nodetype != EPREINC && ind->nd->nodetype != EPOSTINC) {
+        return 0;
+    }
+
+    loop->induction = ind;
+    loop->index24 = ind->nd->index;
+    loop->index20 = IRO_FindStart(ind->nd)->index;
+
+    scan = IRO_FirstNode;
+    memset(&pattern, 0, sizeof(pattern));
+    while (scan) {
+        if (Bv_IsBitSet(scan->index, InLoop) && scan != header) {
+            if (!PatternMatchLoop(scan, loop, ind, &unrollFactor, &result1, &result2, &pattern))
+                return 0;
+        }
+        scan = scan->nextnode;
+    }
+
+    if (result1 > 1 || result2 > 1)
+        return 0;
+
+    lastlabel = fnode2->last->u.label.label;
+    lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);
+
+    IRO_InitList(&list);
+    IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4->u.diadic.left, &list);
+    IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    lastlabelnode = list.tail;
+
+    IRO_InitList(&list);
+    earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
+    earlyLoopExitTestLabel = IRO_NewLabel();
+    earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
+    earlyLoopExitTest->u.label.x4 = lastlabelnode;
+    earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
+    earlyLoopExitTest->rtype = LoopNode->last->rtype;
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    origIterationCount = BuildOrigIterationCount_DoWhile(&list, loop);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    savedHead60 = list.head;
+
+    IRO_InitList(&list);
+    preAlignTemp = BuildPreAlignTemp(ind, unrollFactor, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    unrolledFinalValue = BuildUnrolledFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    newFinalValue = BuildNewFinalvalue_DoWhile(origIterationCount, unrollFactor, &list, loop);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    unrolledBodyEntryTest = list.tail;
+
+    IRO_InitList(&list);
+    label = BuildLabel(&list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    savedHead2 = list.head;
+    loophead25 = NULL;
+    for (scan = fnode3; scan && scan != header; scan = scan->nextnode) {
+        IRO_InitList(&list);
+        loopend = scan->last;
+        loopscan = scan->first;
+        while (1) {
+            if (loopscan->stmt)
+                loopscan->stmt->flags |= StmtFlag_10;
+            if (loopscan->type != IROLinearLabel && !(loopscan->flags & IROLF_Reffed)) {
+                IRO_DuplicateExpr(loopscan, &list);
+                if (!loophead25)
+                    loophead25 = list.head;
+            }
+            if (loopscan == loopend)
+                break;
+            loopscan = loopscan->next;
+        }
+
+        if (list.head && list.tail)
+            IRO_Paste(list.head, list.tail, fnode2->last);
+    }
+
+    IRO_InitList(&list);
+
+    if (ind->nd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+    else
+        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+    indvar = list.tail;
+
+    IRO_DuplicateExpr(preAlignTemp, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+
+    less = IRO_NewLinear(IROLinearOp2Arg);
+    less->nodetype = ELESS;
+    less->rtype = TYPE(&stbool);
+    less->index = ++IRO_NumLinear;
+    less->next = NULL;
+    less->u.diadic.left = indvar;
+    less->u.diadic.right = list.tail;
+    IRO_AddToList(less, &list);
+    less->flags |= IROLF_Reffed;
+
+    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+    loopExitTest->u.label.label = label;
+    loopExitTest->u.label.x4 = less;
+    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+    loopExitTest->rtype = LoopNode->last->rtype;
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveTail = list.tail;
+
+    IRO_InitList(&list);
+    label2 = IRO_NewLabel();
+    gotond = IRO_NewLinear(IROLinearOp1Arg);
+    gotond->index = ++IRO_NumLinear;
+    gotond->type = IROLinearGoto;
+    gotond->u.label.label = label2;
+    IRO_AddToList(gotond, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    label3 = BuildLabel(&list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    savedHead3 = list.head;
+
+    UnrollWhileLoopBody(header, fnode2, fnode3, loop, &pattern, unrollFactor);
+    updIndInc = UpdateInductionIncrement(loop, 8 * unrollFactor, fnode2->last);
+
+    IRO_InitList(&list);
+    label2nd = IRO_NewLinear(IROLinearLabel);
+    label2nd->index = IRO_NumLinear++;
+    label2nd->u.label.label = label2;
+    label2nd->flags |= IROLF_1;
+    IRO_AddToList(label2nd, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+
+    if (ind->nd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+    else
+        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+    indvar = list.tail;
+
+    IRO_DuplicateExpr(unrolledFinalValue, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+
+    less2 = IRO_NewLinear(IROLinearOp2Arg);
+    less2->nodetype = ELESS;
+    less2->rtype = TYPE(&stbool);
+    less2->index = ++IRO_NumLinear;
+    less2->next = NULL;
+    less2->u.diadic.left = indvar;
+    less2->u.diadic.right = list.tail;
+    IRO_AddToList(less2, &list);
+    less2->flags |= IROLF_Reffed;
+
+    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+    loopExitTest->u.label.label = label3;
+    loopExitTest->u.label.x4 = less2;
+    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+    loopExitTest->rtype = LoopNode->last->rtype;
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveTail2 = list.tail;
+
+    IRO_InitList(&list);
+
+    if (ind->nd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(ind->nd->u.monadic, &list);
+    else
+        IRO_DuplicateExpr(ind->nd->u.diadic.left, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+    indvar = list.tail;
+
+    IRO_DuplicateExpr(newFinalValue, &list);
+    list.tail->flags &= ~IROLF_Assigned;
+
+    less3 = IRO_NewLinear(IROLinearOp2Arg);
+    less3->nodetype = ELESS;
+    less3->rtype = TYPE(&stbool);
+    less3->index = ++IRO_NumLinear;
+    less3->next = NULL;
+    less3->u.diadic.left = indvar;
+    less3->u.diadic.right = list.tail;
+    IRO_AddToList(less3, &list);
+    less3->flags |= IROLF_Reffed;
+
+    wtf = LoopNode->last->u.label.x4;
+    IRO_Paste(list.head, list.tail, LoopNode->last);
+    LoopNode->last->u.label.x4 = list.tail;
+
+    IRO_InitList(&list);
+
+    constnd = IRO_NewLinear(IROLinearOperand);
+    constnd->index = ++IRO_NumLinear;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = wtf->u.diadic.left->rtype;
+    expr->data.intval = cint64_zero;
+    constnd->u.node = expr;
+    constnd->rtype = expr->rtype;
+    IRO_AddToList(constnd, &list);
+    constnd->flags |= IROLF_Reffed;
+
+    IRO_DuplicateExpr(wtf->u.diadic.left, &list);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->nodetype = EASS;
+    ass->rtype = list.tail->rtype;
+    ass->index = ++IRO_NumLinear;
+    ass->next = NULL;
+    ass->u.diadic.left = list.tail;
+    ass->u.diadic.right = constnd;
+    IRO_AddToList(ass, &list);
+    ass->flags |= IROLF_Assigned;
+
+    IRO_NopOut(wtf);
+
+    fn19 = fnode2->nextnode;
+    nd18 = fnode2->last;
+    fnode2->last = earlyLoopExitTest;
+
+    newfnode1 = IRO_NewFlowGraphNode();
+    newfnode1->first = savedHead60;
+    newfnode1->last = unrolledBodyEntryTest;
+    fnode2->nextnode = newfnode1;
+
+    newfnode2 = IRO_NewFlowGraphNode();
+    newfnode2->first = savedHead2;
+    newfnode2->last = saveTail;
+    savedHead2->u.label.label->stmt = (Statement *) newfnode2;
+    newfnode1->nextnode = newfnode2;
+
+    newfnode3 = IRO_NewFlowGraphNode();
+    newfnode3->first = gotond;
+    newfnode3->last = gotond;
+    newfnode2->nextnode = newfnode3;
+
+    newfnode4 = IRO_NewFlowGraphNode();
+    newfnode4->first = savedHead3;
+    newfnode4->last = updIndInc;
+    savedHead3->u.label.label->stmt = (Statement *) newfnode4;
+    newfnode3->nextnode = newfnode4;
+
+    newfnode5 = IRO_NewFlowGraphNode();
+    newfnode5->first = label2nd;
+    newfnode5->last = saveTail2;
+    label2nd->u.label.label->stmt = (Statement *) newfnode5;
+    newfnode4->nextnode = newfnode5;
+
+    newfnode6 = IRO_NewFlowGraphNode();
+    newfnode6->first = nd18;
+    newfnode6->last = nd18;
+    newfnode5->nextnode = newfnode6;
+    newfnode6->nextnode = fn19;
+
+    newfnode7 = oalloc(sizeof(IRONode));
+    memset(newfnode7, 0, sizeof(IRONode));
+    newfnode7->index = IRO_NumNodes;
+    IRO_NumNodes++;
+
+    newfnode7->first = list.head;
+    newfnode7->last = list.tail;
+
+    list.tail->next = LoopNode->last->next;
+    LoopNode->last->next = list.head;
+
+    newfnode7->nextnode = LoopNode->nextnode;
+    LoopNode->nextnode = newfnode7;
+
+    newfnode8 = oalloc(sizeof(IRONode));
+    memset(newfnode8, 0, sizeof(IRONode));
+    newfnode8->index = IRO_NumNodes;
+    IRO_NumNodes++;
+
+    lastnd = IRO_NewLinear(IROLinearLabel);
+    lastnd->index = IRO_NumLinear++;
+    lastnd->next = NULL;
+    lastnd->u.label.label = earlyLoopExitTestLabel;
+    lastnd->flags |= IROLF_1;
+    earlyLoopExitTestLabel->stmt = (Statement *) newfnode8;
+
+    newfnode8->first = lastnd;
+    newfnode8->last = lastnd;
+
+    lastnd->next = newfnode7->last->next;
+    newfnode7->last->next = lastnd;
+
+    newfnode8->nextnode = newfnode7->nextnode;
+    newfnode7->nextnode = newfnode8;
+
+    return 1;
 }
 
-void IRO_IterateForLoopBody() {
+void IRO_IterateForLoopBody(IRONode *start, IRONode *end, IROLoop *loop, IROLinear *destnode, SInt32 addConst, CInt64 *val, Boolean funkyFlag) {
+    IROLinear *first = NULL;
+    IROLinear *last = NULL;
+    IRONode *fnode;
+    IROLinear *lastnd;
+    IROLinear *nd;
+    IROList list;
+
+    for (fnode = start; fnode && fnode != end; fnode = fnode->nextnode) {
+        IRO_InitList(&list);
+
+        lastnd = fnode->last;
+        nd = fnode->first;
+        while (1) {
+            if (nd->stmt)
+                nd->stmt->flags |= StmtFlag_10;
+
+            if (
+                (nd->index < loop->index20 || nd->index > loop->index24) &&
+                nd->type != IROLinearLabel &&
+                !(nd->flags & IROLF_Reffed)
+                )
+            {
+                IRO_DuplicateExpr(nd, &list);
+                if (!first)
+                    first = list.head;
+                last = list.tail;
+            }
+
+            if (nd == lastnd)
+                break;
+            nd = nd->next;
+        }
+
+        if (list.head && list.tail)
+            IRO_Paste(list.head, list.tail, destnode);
+    }
+
+    if (funkyFlag) {
+        *val = CInt64_Add(*val, IRO_MakeLong(loop->induction->addConst));
+        ChangeInductionReference(first, last, *val, loop);
+    }
 }
 
-void IRO_LinearizeForLoopPostLoop() {
+void IRO_LinearizeForLoopPostLoop(IRONode *fnode1, IRONode *fnode2, IROLoop *loop, IRONode *fnode3, UInt32 unrollFactor) {
+    IRONode *newfnode;
+    IROLinear *newnd;
+    SInt32 i;
+    CInt64 val;
+
+    newfnode = oalloc(sizeof(IRONode));
+    memset(newfnode, 0, sizeof(IRONode));
+    newfnode->index = IRO_NumNodes;
+    IRO_NumNodes++;
+
+    newnd = IRO_NewLinear(IROLinearNop);
+    newnd->index = IRO_NumLinear++;
+    newnd->next = NULL;
+    newnd->flags |= IROLF_1;
+
+    newfnode->first = newfnode->last = newnd;
+
+    newfnode->nextnode = fnode3->nextnode;
+    fnode3->nextnode = newfnode;
+
+    newnd->next = fnode3->last->next;
+    fnode3->last->next = newnd;
+
+    val = cint64_zero;
+    for (i = 0; i < unrollFactor; i++)
+        IRO_IterateForLoopBody(fnode2, fnode1, loop, newfnode->last, loop->induction->addConst, &val, i > 0);
+    UpdateInductionIncrement(loop, unrollFactor, newfnode->last);
 }
 
-static void UnrollForLoop() {
+static UInt32 UnrollForLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, IROLoop *loop, UInt32 unrollFactor) {
+    IROLinear *lastlabelnode;
+    IROLinear *earlyLoopExitTest;
+    IROLinear *origIterationCount;
+    IROLinear *saveHead1;
+    IROLinear *newFinalValue;
+    IROLinear *unrolledBodyEntryTest;
+    IROLinear *gotoNd;
+    IROLinear *saveHead2;
+    IROLinear *updIndInc;
+    IROLinear *labelNd;
+    IROLinear *saveTail2;
+    IROLinear *ndCopy;
+    IROLinear *saveTail3;
+    IROLinear *loopExitTest;
+    IROLinear *lastnd;
+    IROLinear *labelNd2;
+    IROLinear *saveTail4;
+    IROLinear *labelNd3;
+    IROLinear *scan;
+    IRONode *nd18;
+    IRONode *newfnode1;
+    IRONode *newfnode2;
+    IRONode *newfnode3;
+    IRONode *newfnode4;
+    IRONode *newfnode5;
+    IRONode *newfnode6;
+    CLabel *lastlabel;
+    CLabel *earlyLoopExitTestLabel;
+    CLabel *label;
+    CLabel *label2;
+    SInt32 i;
+
+    IROList list;
+    CInt64 iterCount;
+    int isConstant;
+    UInt32 needOrigLoop = 0;
+    UInt32 needUnrollBodyTest = 0;
+    UInt32 resetUnrolledFinalValue = 0;
+    SInt32 leftOver;
+    CInt64 val;
+
+    lastlabelnode = IRO_FindLabelNode(fnode2->last->u.label.label, fnode2->last);
+    lastlabel = IRO_NewLabel();
+
+    IRO_InitList(&list);
+    IRO_DuplicateExprRange(lastlabelnode->next, LoopNode->last->u.label.x4, &list);
+    IRO_DuplicateExpr(LoopNode->last->u.label.x4, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    lastlabelnode = list.tail;
+
+    IRO_InitList(&list);
+    earlyLoopExitTest = BuildEarlyLoopExitTest(LoopNode->last->type, &list);
+    earlyLoopExitTestLabel = IRO_NewLabel();
+    earlyLoopExitTest->u.label.label = earlyLoopExitTestLabel;
+    earlyLoopExitTest->u.label.x4 = lastlabelnode;
+    earlyLoopExitTest->u.label.x4->flags |= IROLF_Reffed;
+    earlyLoopExitTest->rtype = LoopNode->last->rtype;
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    isConstant = IsIterationCountConstant(loop, &iterCount);
+    needOrigLoop = 1;
+    needUnrollBodyTest = 1;
+    resetUnrolledFinalValue = 0;
+    if (isConstant)
+        IRO_TestConstantIterationCount(loop, &iterCount, 1, &unrollFactor, &leftOver, &needOrigLoop, &needUnrollBodyTest, &resetUnrolledFinalValue);
+
+    IRO_InitList(&list);
+    origIterationCount = BuildOrigIterationCount(&list, loop);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveHead1 = list.head;
+
+    IRO_InitList(&list);
+    newFinalValue = BuildNewFinalvalue(origIterationCount, unrollFactor, &list, loop);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    BuildUnrolledBodyEntryTest(&list, origIterationCount, unrollFactor, lastlabel);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    unrolledBodyEntryTest = list.tail;
+
+    label = IRO_NewLabel();
+    IRO_InitList(&list);
+    gotoNd = IRO_NewLinear(IROLinearOp1Arg);
+    gotoNd->index = ++IRO_NumLinear;
+    gotoNd->type = IROLinearGoto;
+    gotoNd->u.label.label = label;
+    IRO_AddToList(gotoNd, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+    label2 = BuildLabel(&list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveHead2 = list.head;
+
+    val = cint64_zero;
+    for (i = 0; i < unrollFactor; i++)
+        IRO_IterateForLoopBody(fnode3, header, loop, fnode2->last, loop->induction->addConst, &val, i > 0);
+    updIndInc = UpdateInductionIncrement(loop, unrollFactor, fnode2->last);
+
+    IRO_InitList(&list);
+    labelNd = IRO_NewLinear(IROLinearLabel);
+    labelNd->index = IRO_NumLinear++;
+    labelNd->u.label.label = label;
+    labelNd->flags |= IROLF_1;
+    IRO_AddToList(labelNd, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    IRO_InitList(&list);
+
+    IRO_DuplicateExpr(LoopNode->last->u.label.x4->u.diadic.left, &list);
+    saveTail2 = list.tail;
+
+    if (resetUnrolledFinalValue)
+        IRO_DuplicateExpr(loop->nd18->u.diadic.right, &list);
+    else
+        IRO_DuplicateExpr(newFinalValue, &list);
+
+    ndCopy = IRO_NewLinear(LoopNode->last->u.label.x4->type);
+    *ndCopy = *LoopNode->last->u.label.x4;
+    ndCopy->index = ++IRO_NumLinear;
+    ndCopy->next = NULL;
+    ndCopy->expr = NULL;
+    ndCopy->u.diadic.left = saveTail2;
+    ndCopy->u.diadic.right = list.tail;
+    IRO_AddToList(ndCopy, &list);
+
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveTail3 = list.tail;
+
+    IRO_InitList(&list);
+    loopExitTest = BuildLoopExitTest(LoopNode->last->type, &list);
+    loopExitTest->u.label.label = label2;
+    loopExitTest->u.label.x4 = saveTail3;
+    loopExitTest->u.label.x4->flags |= IROLF_Reffed;
+    loopExitTest->rtype = LoopNode->last->rtype;
+    IRO_Paste(list.head, list.tail, fnode2->last);
+    saveTail4 = list.tail;
+
+    IRO_InitList(&list);
+    labelNd2 = IRO_NewLinear(IROLinearLabel);
+    labelNd2->index = IRO_NumLinear++;
+    labelNd2->u.label.label = lastlabel;
+    labelNd2->flags |= IROLF_1;
+    IRO_AddToList(labelNd2, &list);
+    IRO_Paste(list.head, list.tail, fnode2->last);
+
+    lastnd = fnode2->last;
+    nd18 = fnode2->nextnode;
+    fnode2->last = earlyLoopExitTest;
+
+    newfnode1 = IRO_NewFlowGraphNode();
+    newfnode1->first = saveHead1;
+    newfnode1->last = unrolledBodyEntryTest;
+    fnode2->nextnode = newfnode1;
+
+    newfnode2 = IRO_NewFlowGraphNode();
+    newfnode2->first = gotoNd;
+    newfnode2->last = gotoNd;
+    newfnode1->nextnode = newfnode2;
+
+    newfnode3 = IRO_NewFlowGraphNode();
+    newfnode3->first = saveHead2;
+    newfnode3->last = updIndInc;
+
+    saveHead2->u.label.label->stmt = (Statement *) newfnode3;
+    if (newfnode2)
+        newfnode2->nextnode = newfnode3;
+    else
+        newfnode1->nextnode = newfnode3;
+
+    newfnode4 = IRO_NewFlowGraphNode();
+    newfnode4->first = labelNd;
+    newfnode4->last = saveTail4;
+    labelNd->u.label.label->stmt = (Statement *) newfnode4;
+    newfnode3->nextnode = newfnode4;
+
+    newfnode5 = IRO_NewFlowGraphNode();
+    newfnode5->first = labelNd2;
+    newfnode5->last = lastnd;
+    newfnode4->nextnode = newfnode5;
+    newfnode5->nextnode = nd18;
+
+    newfnode6 = oalloc(sizeof(IRONode));
+    memset(newfnode6, 0, sizeof(IRONode));
+    newfnode6->index = IRO_NumNodes;
+    IRO_NumNodes++;
+
+    labelNd3 = IRO_NewLinear(IROLinearLabel);
+    labelNd3->index = IRO_NumLinear++;
+    labelNd3->next = NULL;
+    labelNd3->u.label.label = earlyLoopExitTestLabel;
+    labelNd3->flags |= IROLF_1;
+    earlyLoopExitTestLabel->stmt = (Statement *) newfnode6;
+
+    newfnode6->first = labelNd3;
+    newfnode6->last = labelNd3;
+
+    labelNd3->next = LoopNode->last->next;
+    LoopNode->last->next = labelNd3;
+
+    newfnode6->nextnode = LoopNode->nextnode;
+    LoopNode->nextnode = newfnode6;
+
+    if (!needOrigLoop) {
+        NoOpBlock(newfnode5);
+        NoOpBlock(header);
+        NoOpBlock(fnode3);
+        NoOpBlock(loop->induction->fnode);
+        IRO_NopOut(newfnode1->last->u.label.x4);
+        newfnode1->last->type = IROLinearNop;
+    }
+
+    if (!needUnrollBodyTest) {
+        IRO_NopOut(earlyLoopExitTest->u.label.x4);
+        earlyLoopExitTest->type = IROLinearNop;
+
+        IRO_NopOut(newfnode4->last->u.label.x4);
+        newfnode4->last->type = IROLinearNop;
+
+        if (newfnode2)
+            newfnode2->last->type = IROLinearNop;
+
+        for (scan = newfnode1->first; scan; scan = scan->next) {
+            if (!(scan->flags & IROLF_Reffed))
+                IRO_NopOut(scan);
+            if (scan == newfnode1->last)
+                break;
+        }
+    }
+
+    return 1;
 }
 
-static void UnrollStandardLoop() {
+static UInt32 UnrollStandardLoop(IRONode *header, IRONode *fnode2, IRONode *fnode3, int count) {
+    IROLoop *loop;
+
+    ConditionalHeaderAtBottom = 1;
+    loop = ExtractLoopInfo(header);
+    loop->xC = fnode2;
+    loop->x10 = fnode3;
+    FindAssignmenttoInductionVar(loop, fnode2);
+
+    if (!IsLoopUnrollable(loop)) {
+        IRO_Dump("LoopUnroll:loop with header %d not unrolled because IsLoopUnrollable failed\n", header->index);
+        return 0;
+    }
+
+    if (loop->flags & LoopFlags_10000)
+        return UnrollWhileLoop(header, fnode2, fnode3, loop, count);
+    else
+        return UnrollForLoop(header, fnode2, fnode3, loop, count);
 }
 
-static void LoopUnroll() {
+static void LoopUnroll(int count, IRONode *header) {
+    VarRecord *var;
+    IRONode *tmp;
+    UInt16 i;
+    UInt16 j;
+    IRONode *prevpred;
+    IRONode *prevsucc;
+    int foundpred;
+    UInt32 predcount;
+    UInt32 success = 0;
+
+    LoopNode = header;
+    FindMustReach();
+
+    for (var = IRO_FirstVar; var; var = var->next)
+        var->xA = 1;
+
+    ComputeLoopKills();
+    ComputeLoopInvariance();
+    ComputeLoopInduction();
+
+    LoopNode = header;
+    ConditionalHeaderAtBottom = 0;
+
+    prevpred = NULL;
+    foundpred = 0;
+    for (i = 0; i < LoopNode->numpred; i++) {
+        tmp = IRO_NodeTable[LoopNode->pred[i]];
+        if (!Bv_IsBitSet(tmp->index, InLoop)) {
+            foundpred = 1;
+            if (tmp->nextnode == header) {
+                CError_ASSERT(2101, !prevpred || tmp == prevpred);
+                prevpred = tmp;
+            }
+        }
+    }
+
+    if (!foundpred) {
+        IRO_Dump("No predecessor outside the loop\n");
+        return;
+    }
+
+    if (LoopNode->last->type == IROLinearIf || LoopNode->last->type == IROLinearIfNot) {
+        if (LoopNode->nextnode && !Bv_IsBitSet(LoopNode->nextnode->index, InLoop)) {
+            prevsucc = NULL;
+            for (i = 0; i < LoopNode->numsucc; i++) {
+                tmp = IRO_NodeTable[LoopNode->succ[i]];
+                if (Bv_IsBitSet(tmp->index, InLoop)) {
+                    CError_ASSERT(2159, !prevsucc);
+                    prevsucc = tmp;
+                }
+            }
+
+            prevpred = NULL;
+            predcount = 0;
+            for (j = 0; j < LoopNode->numpred; j++) {
+                tmp = IRO_NodeTable[LoopNode->pred[j]];
+                if (!Bv_IsBitSet(tmp->index, InLoop)) {
+                    prevpred = tmp;
+                    predcount++;
+                }
+            }
+
+            if (
+                predcount == 1 &&
+                prevpred->last->type == IROLinearGoto &&
+                prevpred->nextnode == prevsucc &&
+                prevsucc != LoopNode
+                )
+            {
+                success = UnrollStandardLoop(header, prevpred, prevsucc, count);
+            }
+        }
+    } else {
+        IRO_Dump(" LoopUnroll:Loop with header = %d is not a conditional loop\n", header->index);
+    }
+
+    if (!success)
+        return;
+
+    IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
+    memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
+    for (tmp = IRO_FirstNode; tmp; tmp = tmp->nextnode)
+        IRO_NodeTable[tmp->index] = tmp;
+    IRO_ComputeSuccPred();
+    IRO_ComputeDom();
+    if (success)
+        IRO_Dump(" LoopUnroll:Loop with header = %d Unrolled\n", header->index);
 }
 
-static void IsLoopUnrollable() {
+static int IsLoopUnrollable(IROLoop *loop) {
+    CInt64 tmp;
+
+    if (loop->flags & LP_LOOP_HAS_ASM) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_ASM \n");
+        return 0;
+    }
+    if (loop->flags & LP_IFEXPR_NON_CANONICAL) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_IFEXPR_NON_CANONICAL \n");
+        return 0;
+    }
+    if (loop->flags & LP_LOOP_HAS_CALLS) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CALLS \n");
+        return 0;
+    }
+    if (loop->flags & LP_LOOP_HAS_CNTRLFLOW) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HAS_CNTRLFLOW \n");
+        return 0;
+    }
+    if (loop->flags & LP_INDUCTION_NOT_FOUND) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_INDUCTION_NOT_FOUND \n");
+        return 0;
+    }
+    if (loop->flags & LP_LOOP_HDR_HAS_SIDEEFFECTS) {
+        IRO_Dump("IsLoopUnrollable:No due to LP_LOOP_HDR_HAS_SIDEEFFECTS \n");
+        return 0;
+    }
+    if (!(loop->flags & LoopFlags_200)) {
+        IRO_Dump("IsLoopUnrollable:No because header does not follow induction update \n");
+        return 0;
+    }
+
+    if (!(loop->flags & LoopFlags_10000)) {
+        IROLinear *upperBound = loop->nd18->u.diadic.right;
+        if (!IRO_IsIntConstant(upperBound) && !(upperBound->flags & IROLF_LoopInvariant)) {
+            IRO_Dump("IsLoopUnrollable:No because Loop Upper Bound is Variant in the loop\n");
+            return 0;
+        }
+        if (!loop->nd14) {
+            IRO_Dump("IsLoopUnrollable:No because there is no initialization of loop index in PreHeader\n");
+            return 0;
+        }
+        if (!IRO_IsVariable(loop->nd14->u.diadic.left)) {
+            IRO_Dump("IsLoopUnrollable:No because initial value of induction stored thru pointer\n");
+            return 0;
+        }
+
+        if (!IRO_IsUnsignedType(loop->nd14->rtype)) {
+            if (IRO_IsIntConstant(loop->nd14->u.diadic.right)) {
+                if (!CInt64_GreaterEqual(loop->nd14->u.diadic.right->u.node->data.intval, cint64_zero)) {
+                    IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed but init < 0\n");
+                    return 0;
+                }
+            } else if (IsIterationCountConstant(loop, &tmp)) {
+                IRO_Dump("IsLoopUnrollable:Yes, the limits substract out to be constants\n");
+            } else {
+                IRO_Dump("IsLoopUnrollable:No because initial value of induction is signed and not constant\n");
+                return 0;
+            }
+        }
+
+        if (!(loop->flags & LP_LOOP_STEP_ISADD)) {
+            IRO_Dump("IsLoopUnrollable:No because LP_LOOP_STEP_ISADD  is not set i.e induciton is not updated by 1\n");
+            return 0;
+        }
+
+    } else {
+        if (!IRO_IsUnsignedType(loop->nd18->u.diadic.left->rtype)) {
+            IRO_Dump("IsLoopUnrollable:No because the while loop induction is signed\n");
+            return 0;
+        }
+        if (!(loop->flags & LoopFlags_2000)) {
+            IRO_Dump("IsLoopUnrollable:No because the while loop operator is not of decrement form\n");
+            return 0;
+        }
+    }
+
+    if (loop->sizeBySomeMeasurement > copts.loop_unroll_size_threshold) {
+        IRO_Dump("IsLoopUnrollable:No because loop size greater than threshold\n");
+        return 0;
+    }
+
+    return 1;
 }
 
-void BuildEarlyLoopExitTest() {
+IROLinear *BuildEarlyLoopExitTest(IROLinearType type, IROList *list) {
+    IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
+    nd->index = ++IRO_NumLinear;
+    if (type == IROLinearIf)
+        nd->type = IROLinearIfNot;
+    else
+        nd->type = IROLinearIf;
+    IRO_AddToList(nd, list);
+    return nd;
 }
 
-void BuildLoopExitTest() {
+IROLinear *BuildLoopExitTest(IROLinearType type, IROList *list) {
+    IROLinear *nd = IRO_NewLinear(IROLinearOp1Arg);
+    nd->index = ++IRO_NumLinear;
+    nd->type = type;
+    IRO_AddToList(nd, list);
+    return nd;
 }
 
-void IsIterationCountConstant() {
+int IsIterationCountConstant(IROLoop *loop, CInt64 *pval) {
+    IROLinear *lowerBound;
+    IROLinear *upperBound;
+    Type *type;
+    int isUnsigned;
+    IROAddrRecord *lowerRec;
+    IROAddrRecord *upperRec;
+    CInt64 lowerval;
+    CInt64 upperval;
+    CInt64 incval;
+    CInt64 negOne;
+
+    lowerBound = loop->nd14->u.diadic.right;
+    if (loop->flags & LoopFlags_1) {
+        upperBound = loop->nd18->u.diadic.right;
+        type = loop->nd18->u.diadic.right->rtype;
+    } else {
+        upperBound = loop->nd18->u.diadic.left;
+        type = loop->nd18->u.diadic.left->rtype;
+    }
+
+    isUnsigned = IRO_IsUnsignedType(type);
+
+    if (IRO_IsIntConstant(lowerBound) && IRO_IsIntConstant(upperBound)) {
+        lowerval = lowerBound->u.node->data.intval;
+        upperval = upperBound->u.node->data.intval;
+        if (isUnsigned) {
+            if (CInt64_LessEqualU(upperval, lowerval))
+                return 0;
+        } else {
+            if (CInt64_LessEqual(upperval, lowerval))
+                return 0;
+        }
+
+        CInt64_SetLong(&incval, loop->induction->addConst);
+        CInt64_SetLong(&negOne, -1);
+        *pval = CInt64_Sub(upperval, lowerval);
+        *pval = CInt64_Add(*pval, incval);
+
+        if (IS_LINEAR_DIADIC(loop->nd18, ELESS))
+            *pval = CInt64_Add(*pval, negOne);
+
+        CError_ASSERT(2486, !CInt64_IsZero(&incval));
+
+        if (isUnsigned)
+            *pval = CInt64_DivU(*pval, incval);
+        else
+            *pval = CInt64_Div(*pval, incval);
+
+        if (CInt64_Equal(*pval, cint64_zero))
+            return 0;
+
+        if (isUnsigned) {
+            CError_ASSERT(2508, !CInt64_LessEqualU(*pval, cint64_zero));
+        } else {
+            CError_ASSERT(2517, !CInt64_LessEqual(*pval, cint64_zero));
+        }
+
+        return 1;
+    }
+
+    lowerRec = IRO_InitAddrRecordPointer(lowerBound);
+    upperRec = IRO_InitAddrRecordPointer(upperBound);
+
+    if (IS_LINEAR_DIADIC(lowerBound, EADD)) {
+        IRO_DecomposeAddressExpression(lowerBound, lowerRec);
+    } else if (IRO_IsIntConstant(lowerBound)) {
+        lowerRec->numInts++;
+        IRO_AddElmToList(lowerBound, &lowerRec->ints);
+        lowerRec->numObjRefs = 0;
+        lowerRec->numMisc = 0;
+    } else {
+        lowerRec->numMisc++;
+        IRO_AddElmToList(lowerBound, &lowerRec->misc);
+        lowerRec->numObjRefs = 0;
+        lowerRec->numInts = 0;
+    }
+
+    if (IS_LINEAR_DIADIC(upperBound, EADD)) {
+        IRO_DecomposeAddressExpression(upperBound, upperRec);
+    } else if (IRO_IsIntConstant(upperBound)) {
+        upperRec->numInts++;
+        IRO_AddElmToList(upperBound, &upperRec->ints);
+        upperRec->numObjRefs = 0;
+        upperRec->numMisc = 0;
+    } else {
+        upperRec->numMisc++;
+        IRO_AddElmToList(upperBound, &upperRec->misc);
+        upperRec->numObjRefs = 0;
+        upperRec->numInts = 0;
+    }
+
+    if (IsDifferenceOfTermsConstant(lowerRec, upperRec, isUnsigned, pval)) {
+        if (IS_LINEAR_DIADIC(loop->nd18, ELESSEQU))
+            *pval = CInt64_Add(*pval, cint64_one);
+        return 1;
+    }
+
+    return 0;
 }
 
-static void IsDifferenceOfTermsConstant() {
+static int IsDifferenceOfTermsConstant(IROAddrRecord *lowerRec, IROAddrRecord *upperRec, int isUnsigned, CInt64 *pval) {
+    UInt32 i;
+    CInt64 upperval;
+    CInt64 lowerval;
+    IROElmList *el;
+    IROLinear *nd;
+
+    if (upperRec->numObjRefs == lowerRec->numObjRefs && upperRec->numObjRefs != 0)
+        return 0;
+    else if (upperRec->numObjRefs != lowerRec->numObjRefs)
+        return 0;
+
+    if (upperRec->numMisc == lowerRec->numMisc && upperRec->numMisc != 0) {
+        for (i = 0; i < upperRec->numMisc; i++) {
+            // bug? surely this should index on i...?
+            if (!IRO_ExprsSame(lowerRec->misc->element, upperRec->misc->element))
+                return 0;
+        }
+    } else if (upperRec->numMisc != lowerRec->numMisc) {
+        return 0;
+    }
+
+    upperval = cint64_zero;
+    for (el = upperRec->ints; el; el = el->next) {
+        nd = el->element;
+        upperval = CMach_CalcIntDiadic(nd->rtype, upperval, '+', nd->u.node->data.intval);
+    }
+
+    lowerval = cint64_zero;
+    for (el = lowerRec->ints; el; el = el->next) {
+        nd = el->element;
+        lowerval = CMach_CalcIntDiadic(nd->rtype, lowerval, '+', nd->u.node->data.intval);
+    }
+
+    if (CInt64_Equal(upperval, lowerval))
+        return 0;
+
+    if (CInt64_Greater(upperval, lowerval)) {
+        *pval = CInt64_Sub(upperval, lowerval);
+        return 1;
+    } else {
+        return 0;
+    }
 }
 
-void NoOpBlock() {
+void NoOpBlock(IRONode *fnode) {
+    IROLinear *last, *scan;
+
+    for (scan = fnode->first, last = fnode->last; scan; scan = scan->next) {
+        scan->type = IROLinearNop;
+        if (scan == last)
+            break;
+    }
 }
 
-void IRO_TestConstantIterationCount() {
+void IRO_TestConstantIterationCount(IROLoop *loop, CInt64 *iterCount, SInt32 vectorStride, UInt32 *unrollFactor, SInt32 *leftOver, UInt32 *needOrigLoop, UInt32 *needUnrollBodyTest, UInt32 *resetUnrolledFinalValue) {
+    UInt32 isUnsigned;
+    CInt64 val;
+    CInt64 val3;
+    CInt64 mod;
+    CInt64 val2;
+    CInt64 loopvar3;
+    CInt64 loopvar1;
+    CInt64 loopvar2;
+    CInt64 strideVal;
+
+    CError_ASSERT(2737, *unrollFactor);
+
+    isUnsigned = IRO_IsUnsignedType(
+        (loop->flags & LoopFlags_1) ? loop->nd18->u.diadic.right->rtype :loop->nd18->u.diadic.left->rtype);
+
+    CError_ASSERT(2756, vectorStride);
+
+    strideVal = IRO_MakeLong(vectorStride);
+    if (isUnsigned ? CInt64_LessU(*iterCount, strideVal) : CInt64_Less(*iterCount, strideVal)) {
+        *needOrigLoop = 1;
+        *needUnrollBodyTest = 0;
+        *unrollFactor = 0;
+        *leftOver = CInt64_GetULong(iterCount);
+    } else {
+        switch (vectorStride) {
+            case 1:
+                val = *iterCount;
+                break;
+            case 2:
+                val = CInt64_ShrU(*iterCount, cint64_one);
+                break;
+            case 4:
+                val = CInt64_ShrU(*iterCount, IRO_MakeLong(2));
+                break;
+            case 8:
+                val = CInt64_ShrU(*iterCount, IRO_MakeLong(3));
+                break;
+            case 16:
+                val = CInt64_ShrU(*iterCount, IRO_MakeLong(4));
+                break;
+            default:
+                val = CInt64_Div(*iterCount, strideVal);
+        }
+
+        if (CInt64_LessU(val, IRO_MakeLong(*unrollFactor)))
+            *unrollFactor = CInt64_GetULong(&val);
+
+        CInt64_SetLong(&val2, *unrollFactor);
+        switch (vectorStride) {
+            case 1:
+                val3 = cint64_zero;
+                break;
+            case 2:
+                val3 = CInt64_And(*iterCount, cint64_one);
+                break;
+            case 4:
+                val3 = CInt64_And(*iterCount, IRO_MakeLong(3));
+                break;
+            case 8:
+                val3 = CInt64_And(*iterCount, IRO_MakeLong(7));
+                break;
+            case 16:
+                val3 = CInt64_And(*iterCount, IRO_MakeLong(15));
+                break;
+            default:
+                val3 = CInt64_Mod(*iterCount, strideVal);
+        }
+
+        if (CInt64_LessEqualU(val, IRO_MakeLong(8))) {
+            *needUnrollBodyTest = vectorStride > 1;
+            *unrollFactor = CInt64_GetULong(&val);
+            *leftOver = CInt64_GetULong(&val3);
+            *needOrigLoop = *leftOver != 0;
+            *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
+        } else {
+            loopvar1 = IRO_MakeLong(0x7FFFFFFF);
+            loopvar2 = IRO_MakeLong(0x7FFFFFFF);
+            do {
+                mod = CInt64_Mod(val, val2);
+                loopvar3 = CInt64_Add(CInt64_Mul(mod, strideVal), val3);
+                if (CInt64_Less(loopvar3, loopvar2)) {
+                    loopvar2 = loopvar3;
+                    loopvar1 = val2;
+                }
+                if (vectorStride > 1)
+                    break;
+                val2 = CInt64_Add(val2, cint64_negone);
+            } while (CInt64_GreaterEqualU(CInt64_Mul(val2, val2), val));
+
+            *unrollFactor = CInt64_GetULong(&loopvar1);
+            *leftOver = CInt64_GetULong(&loopvar2);
+            *needOrigLoop = *leftOver != 0;
+            *needUnrollBodyTest = CInt64_Less(loopvar1, val) || vectorStride > 1;
+            *resetUnrolledFinalValue = !(*needOrigLoop && *needUnrollBodyTest);
+        }
+    }
+
+    IRO_Dump(
+        "---- IterCount = %d, VectorStride = %d, UnrollFactor = %d, LeftOver = %d,\n"
+        "\tNeedOrigLoop = %d, NeedUnrollBodyTest = %d, ResetUnrolledFinalValue = %d\n",
+        CInt64_GetULong(iterCount), vectorStride, *unrollFactor, *leftOver,
+        *needOrigLoop, *needUnrollBodyTest, *resetUnrolledFinalValue
+        );
 }
 
-void BuildOrigIterationCount() {
+IROLinear *BuildOrigIterationCount(IROList *list, IROLoop *loop) {
+    IROLinear *upperBound;
+    IROLinear *nd29b;
+    IROLinear *lowerBound;
+    IROLinear *finalCount;
+    IROLinear *divisor;
+    Type *type;
+    IROLinear *nd25;
+    IROLinear *tmp;
+    Boolean isZeroBase;
+    Object *tempobj;
+    IROLinear *iterCount;
+    IROLinear *negone;
+    IROLinear *ass;
+    ENode *expr;
+    SInt32 powval;
+
+    isZeroBase = 0;
+    lowerBound = loop->nd14->u.diadic.right;
+    if (IRO_IsIntConstant(lowerBound) && CInt64_Equal(lowerBound->u.node->data.intval, cint64_zero))
+        isZeroBase = 1;
+
+    if (!isZeroBase)
+        lowerBound = IRO_DuplicateExpr(lowerBound, list);
+
+    if (loop->flags & LoopFlags_1) {
+        upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
+        type = loop->nd18->u.diadic.right->rtype;
+    } else {
+        upperBound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+        type = loop->nd18->u.diadic.left->rtype;
+    }
+
+    CError_ASSERT(2924, loop->induction);
+    CError_ASSERT(2929, loop->induction->addConst);
+
+    divisor = IRO_NewLinear(IROLinearOperand);
+    divisor->index = ++IRO_NumLinear;
+    divisor->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+    divisor->u.node = expr;
+
+    if (isZeroBase) {
+        iterCount = upperBound;
+    } else {
+        iterCount = IRO_NewLinear(IROLinearOp2Arg);
+        iterCount->index = ++IRO_NumLinear;
+        iterCount->nodetype = ESUB;
+        iterCount->u.diadic.left = upperBound;
+        iterCount->u.diadic.right = lowerBound;
+        iterCount->rtype = type;
+        IRO_AddToList(iterCount, list);
+    }
+
+    nd25 = IRO_DuplicateExpr(divisor, list);
+
+    nd29b = IRO_NewLinear(IROLinearOp2Arg);
+    nd29b->index = ++IRO_NumLinear;
+    nd29b->nodetype = EADD;
+    nd29b->u.diadic.left = iterCount;
+    nd29b->u.diadic.right = nd25;
+    nd29b->rtype = type;
+    IRO_AddToList(nd29b, list);
+
+    if (loop->nd18->type == IROLinearOp2Arg && loop->nd18->nodetype == ELESS) {
+        tmp = nd29b;
+
+        negone = IRO_NewLinear(IROLinearOperand);
+        negone->index = ++IRO_NumLinear;
+        negone->rtype = type;
+        expr = IRO_NewENode(EINTCONST);
+        expr->rtype = type;
+        CInt64_SetLong(&expr->data.intval, -1);
+        negone->u.node = expr;
+        IRO_AddToList(negone, list);
+
+        nd29b = IRO_NewLinear(IROLinearOp2Arg);
+        nd29b->index = ++IRO_NumLinear;
+        nd29b->nodetype = EADD;
+        nd29b->u.diadic.left = tmp;
+        nd29b->u.diadic.right = negone;
+        nd29b->rtype = type;
+        IRO_AddToList(nd29b, list);
+    }
+
+    if (CInt64_Equal(divisor->u.node->data.intval, cint64_one)) {
+        finalCount = nd29b;
+    } else {
+        if (divisor->rtype->size <= 4 && IS_TYPE_INT(divisor->rtype) && IRO_IsPow2(divisor, &powval)) {
+            finalCount = IRO_NewLinear(IROLinearOp2Arg);
+            finalCount->index = ++IRO_NumLinear;
+            finalCount->nodetype = ESHL;
+            finalCount->u.diadic.left = nd29b;
+            finalCount->u.diadic.right = divisor;
+            CInt64_SetLong(&divisor->u.node->data.intval, powval);
+            finalCount->rtype = type;
+            IRO_AddToList(divisor, list);
+            IRO_AddToList(finalCount, list);
+        } else {
+            finalCount = IRO_NewLinear(IROLinearOp2Arg);
+            finalCount->index = ++IRO_NumLinear;
+            finalCount->nodetype = EDIV;
+            finalCount->u.diadic.left = nd29b;
+            finalCount->u.diadic.right = divisor;
+            finalCount->rtype = type;
+            IRO_AddToList(divisor, list);
+            IRO_AddToList(finalCount, list);
+        }
+    }
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = finalCount;
+    ass->u.diadic.right->flags |= IROLF_Reffed;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-static void BuildOrigIterationCount_DoWhile() {
+static IROLinear *BuildOrigIterationCount_DoWhile(IROList *list, IROLoop *loop) {
+    IROLinear *finalCount;
+    IROLinear *count;
+    IROLinear *ass;
+    Type *type;
+    Object *tempobj;
+    ENode *expr;
+
+    type = loop->nd18->u.diadic.left->rtype;
+
+    count = IRO_NewLinear(IROLinearOperand);
+    count->index = ++IRO_NumLinear;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    expr->data.intval = cint64_one;
+    count->u.node = expr;
+    count->rtype = type;
+    IRO_AddToList(count, list);
+    count->flags |= IROLF_Reffed;
+
+    finalCount = IRO_NewLinear(IROLinearOp2Arg);
+    finalCount->index = ++IRO_NumLinear;
+    finalCount->nodetype = EADD;
+    finalCount->rtype = type;
+    finalCount->u.diadic.left = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+    finalCount->u.diadic.left->flags |= IROLF_Reffed;
+    finalCount->u.diadic.left->flags &= ~IROLF_Assigned;
+    finalCount->u.diadic.left->u.monadic->flags &= ~IROLF_Assigned;
+    finalCount->u.diadic.right = count;
+    IRO_AddToList(finalCount, list);
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = finalCount;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-void BuildNewFinalvalue() {
+IROLinear *BuildNewFinalvalue(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+    IROLinear *sub;
+    IROLinear *addvalue;
+    Type *type;
+    IROLinear *ass;
+    IROLinear *dupbound;
+    Object *tempobj;
+    ENode *expr;
+
+    type = iterCount->rtype;
+
+    addvalue = IRO_NewLinear(IROLinearOperand);
+    addvalue->index = ++IRO_NumLinear;
+    addvalue->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
+    addvalue->u.node = expr;
+    IRO_AddToList(addvalue, list);
+
+    if (loop->flags & LoopFlags_1)
+        dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.right, list);
+    else
+        dupbound = IRO_DuplicateExpr(loop->nd18->u.diadic.left, list);
+
+    sub = IRO_NewLinear(IROLinearOp2Arg);
+    sub->index = ++IRO_NumLinear;
+    sub->nodetype = ESUB;
+    sub->u.diadic.left = dupbound;
+    sub->u.diadic.right = addvalue;
+    sub->rtype = type;
+    IRO_AddToList(sub, list);
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = sub;
+    ass->u.diadic.right->flags |= IROLF_Reffed;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-static void BuildPreAlignTemp() {
+static IROLinear *BuildPreAlignTemp(IROLoopInd *ind, UInt32 unrollFactor, IROList *list) {
+    Type *type;
+    IROLinear *indnd;
+    IROLinear *factornd;
+    IROLinear *div;
+    IROLinear *constnd;
+    IROLinear *add;
+    IROLinear *mul;
+    IROLinear *ass;
+    Object *tempobj;
+    ENode *expr;
+
+    indnd = ind->nd;
+    type = indnd->rtype;
+
+    factornd = IRO_NewLinear(IROLinearOperand);
+    factornd->index = ++IRO_NumLinear;
+    factornd->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, unrollFactor);
+    factornd->u.node = expr;
+    IRO_AddToList(factornd, list);
+
+    if (indnd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(indnd->u.monadic, list);
+    else
+        IRO_DuplicateExpr(indnd->u.diadic.left, list);
+
+    list->tail->flags &= ~IROLF_Assigned;
+    list->tail->u.monadic->flags &= ~IROLF_Assigned;
+
+    div = IRO_NewLinear(IROLinearOp2Arg);
+    div->index = ++IRO_NumLinear;
+    div->nodetype = EDIV;
+    div->u.diadic.left = list->tail;
+    div->u.diadic.right = factornd;
+    div->rtype = type;
+    IRO_AddToList(div, list);
+    div->flags |= IROLF_Reffed;
+
+    constnd = IRO_NewLinear(IROLinearOperand);
+    constnd->index = ++IRO_NumLinear;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    expr->data.intval = cint64_one;
+    constnd->u.node = expr;
+    constnd->rtype = type;
+    IRO_AddToList(constnd, list);
+    constnd->flags |= IROLF_Reffed;
+
+    add = IRO_NewLinear(IROLinearOp2Arg);
+    add->index = ++IRO_NumLinear;
+    add->nodetype = EADD;
+    add->u.diadic.left = div;
+    add->u.diadic.right = constnd;
+    add->rtype = type;
+    IRO_AddToList(add, list);
+    add->flags |= IROLF_Reffed;
+
+    IRO_DuplicateExpr(factornd, list);
+
+    mul = IRO_NewLinear(IROLinearOp2Arg);
+    mul->index = ++IRO_NumLinear;
+    mul->nodetype = EMUL;
+    mul->u.diadic.left = add;
+    mul->u.diadic.right = list->tail;
+    mul->rtype = type;
+    IRO_AddToList(mul, list);
+    mul->flags |= IROLF_Reffed;
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = mul;
+    ass->u.diadic.right->flags |= IROLF_Reffed;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-static void BuildNewFinalvalue_DoWhile() {
+static IROLinear *BuildNewFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+    IROLinear *addvalue;
+    IROLinear *add;
+    IROLinear *mul;
+    IROLinear *ass;
+    Type *type;
+    Object *tempobj;
+    ENode *expr;
+
+    type = iterCount->rtype;
+
+    addvalue = IRO_NewLinear(IROLinearOperand);
+    addvalue->index = ++IRO_NumLinear;
+    addvalue->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+    addvalue->u.node = expr;
+    IRO_AddToList(addvalue, list);
+    addvalue->flags |= IROLF_Reffed;
+
+    mul = IRO_NewLinear(IROLinearOp2Arg);
+    mul->index = ++IRO_NumLinear;
+    mul->nodetype = EMUL;
+    mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
+    mul->u.diadic.right = addvalue;
+    mul->rtype = type;
+    IRO_AddToList(mul, list);
+    mul->flags |= IROLF_Reffed;
+    mul->u.diadic.left->flags &= ~IROLF_Assigned;
+    mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;
+
+    if (loop->induction->nd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
+    else
+        IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
+    list->tail->flags &= ~IROLF_Assigned;
+    list->tail->u.diadic.left->flags &= ~IROLF_Assigned;
+
+    add = IRO_NewLinear(IROLinearOp2Arg);
+    add->index = ++IRO_NumLinear;
+    add->nodetype = EADD;
+    add->u.diadic.left = mul;
+    add->u.diadic.right = list->tail;
+    add->rtype = type;
+    IRO_AddToList(add, list);
+    add->flags |= IROLF_Reffed;
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = add;
+    ass->u.diadic.right->flags |= IROLF_Reffed;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-static void BuildUnrolledFinalvalue_DoWhile() {
+static IROLinear *BuildUnrolledFinalvalue_DoWhile(IROLinear *iterCount, UInt32 unrollFactor, IROList *list, IROLoop *loop) {
+    IROLinear *addvalue_mult;
+    IROLinear *addvalue;
+    IROLinear *mul;
+    IROLinear *sub;
+    IROLinear *add;
+    IROLinear *ass;
+    Type *type;
+    Object *tempobj;
+    ENode *expr;
+
+    type = iterCount->rtype;
+
+    addvalue_mult = IRO_NewLinear(IROLinearOperand);
+    addvalue_mult->index = ++IRO_NumLinear;
+    addvalue_mult->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, loop->induction->addConst * unrollFactor);
+    addvalue_mult->u.node = expr;
+    IRO_AddToList(addvalue_mult, list);
+    addvalue_mult->flags |= IROLF_Reffed;
+
+    addvalue = IRO_NewLinear(IROLinearOperand);
+    addvalue->index = ++IRO_NumLinear;
+    addvalue->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, loop->induction->addConst);
+    addvalue->u.node = expr;
+    IRO_AddToList(addvalue, list);
+    addvalue->flags |= IROLF_Reffed;
+
+    mul = IRO_NewLinear(IROLinearOp2Arg);
+    mul->index = ++IRO_NumLinear;
+    mul->nodetype = EMUL;
+    mul->u.diadic.left = IRO_DuplicateExpr(iterCount, list);
+    mul->u.diadic.right = addvalue;
+    mul->rtype = type;
+    IRO_AddToList(mul, list);
+    mul->flags |= IROLF_Reffed;
+    mul->u.diadic.left->flags &= ~IROLF_Assigned;
+    mul->u.diadic.left->u.diadic.left->flags &= ~IROLF_Assigned;
+
+    sub = IRO_NewLinear(IROLinearOp2Arg);
+    sub->index = ++IRO_NumLinear;
+    sub->nodetype = ESUB;
+    sub->u.diadic.left = mul;
+    sub->u.diadic.right = addvalue_mult;
+    sub->rtype = type;
+    IRO_AddToList(sub, list);
+    sub->flags |= IROLF_Reffed;
+
+    if (loop->induction->nd->type == IROLinearOp1Arg)
+        IRO_DuplicateExpr(loop->induction->nd->u.monadic, list);
+    else
+        IRO_DuplicateExpr(loop->induction->nd->u.diadic.left, list);
+    list->tail->flags &= ~IROLF_Assigned;
+    list->tail->u.diadic.left->flags &= ~IROLF_Assigned;
+
+    add = IRO_NewLinear(IROLinearOp2Arg);
+    add->index = ++IRO_NumLinear;
+    add->nodetype = EADD;
+    add->u.diadic.left = sub;
+    add->u.diadic.right = list->tail;
+    add->rtype = type;
+    IRO_AddToList(add, list);
+    add->flags |= IROLF_Reffed;
+
+    tempobj = create_temp_object(type);
+    IRO_FindVar(tempobj, 1, 1);
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->index = ++IRO_NumLinear;
+    ass->nodetype = EASS;
+    ass->u.diadic.left = IRO_TempReference(tempobj, list);
+    ass->u.diadic.left->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.left->u.monadic->flags |= IROLF_Assigned | IROLF_Ind;
+    ass->u.diadic.right = add;
+    ass->u.diadic.right->flags |= IROLF_Reffed;
+    ass->rtype = type;
+    IRO_AddToList(ass, list);
+
+    return ass->u.diadic.left;
 }
 
-void BuildUnrolledBodyEntryTest() {
+void BuildUnrolledBodyEntryTest(IROList *list, IROLinear *iterCount, UInt32 unrollFactor, CLabel *label) {
+    Type *type;
+    IROLinear *ifnot;
+    IROLinear *comp;
+    IROLinear *var;
+    IROLinear *value;
+    ENode *expr;
+
+    type = iterCount->rtype;
+
+    value = IRO_NewLinear(IROLinearOperand);
+    value->index = ++IRO_NumLinear;
+    value->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, unrollFactor);
+    value->u.node = expr;
+    IRO_AddToList(value, list);
+
+    var = IRO_DuplicateExpr(iterCount, list);
+
+    comp = IRO_NewLinear(IROLinearOp2Arg);
+    comp->index = ++IRO_NumLinear;
+    comp->nodetype = EGREATER;
+    comp->u.diadic.left = var;
+    comp->u.diadic.right = value;
+    comp->u.diadic.right->flags |= IROLF_Reffed;
+    comp->rtype = type;
+    IRO_AddToList(comp, list);
+
+    ifnot = IRO_NewLinear(IROLinearOp1Arg);
+    ifnot->index = ++IRO_NumLinear;
+    ifnot->type = IROLinearIfNot;
+    ifnot->u.label.x4 = comp;
+    ifnot->u.label.x4->flags |= IROLF_Reffed;
+    ifnot->rtype = type;
+    ifnot->u.label.label = label;
+    IRO_AddToList(ifnot, list);
 }
 
-void ChangeInductionReference() {
+void ChangeInductionReference(IROLinear *first, IROLinear *last, CInt64 val, IROLoop *loop) {
+    IROLinear *nd;
+    IROLinear *value;
+    IROLinear *add;
+    UInt32 isUnsigned;
+    IROLinear *father;
+    Boolean flag;
+    IROLinear *father2;
+    IROLinear *father3;
+    Type *tmp;
+    UInt32 flag2;
+    Object *varobj;
+    IROLinear *next;
+    ENode *expr;
+    Type *type;
+
+    CInt64 val2;
+    CInt64 val1;
+    IROList list;
+
+    type = loop->induction->nd->rtype;
+    isUnsigned = IRO_IsUnsignedType(type);
+
+    for (nd = first; nd; nd = next) {
+        next = nd->next;
+
+        varobj = IRO_IsVariable(nd);
+        if (varobj && loop->induction->var->object == varobj) {
+            value = IRO_NewLinear(IROLinearOperand);
+            value->index = ++IRO_NumLinear;
+            value->rtype = type;
+            expr = IRO_NewENode(EINTCONST);
+            expr->rtype = type;
+            expr->data.intval = val;
+            value->u.node = expr;
+
+            add = IRO_NewLinear(IROLinearOp2Arg);
+            add->index = ++IRO_NumLinear;
+            add->nodetype = EADD;
+            add->rtype = type;
+
+            father = IRO_LocateFather(nd);
+            flag = 1;
+            if (father && IS_LINEAR_MONADIC(father, ETYPCON)) {
+                tmp = father->rtype;
+                father = IRO_LocateFather(father);
+                if (tmp->type != nd->rtype->type || tmp->size < nd->rtype->size)
+                    flag = 0;
+            }
+
+            flag2 = 0;
+            if (
+                flag &&
+                father &&
+                IS_LINEAR_DIADIC_2(father, ESHL, EMUL) &&
+                IRO_IsIntConstant(father->u.diadic.right) &&
+                (father2 = IRO_LocateFather(father)) &&
+                IS_LINEAR_DIADIC(father2, EADD) &&
+                father2->u.diadic.right == father &&
+                (father3 = IRO_LocateFather(father2))
+                )
+            {
+                IRO_InitList(&list);
+                val2 = father->u.diadic.right->u.node->data.intval;
+                if (father->nodetype == ESHL)
+                    val2 = CInt64_Shl(cint64_one, val2);
+
+                val1 = value->u.node->data.intval;
+                if (isUnsigned)
+                    val1 = CInt64_MulU(val2, val1);
+                else
+                    val1 = CInt64_Mul(val2, val1);
+                value->u.node->data.intval = val1;
+
+                IRO_AddToList(value, &list);
+                IRO_AddToList(add, &list);
+                add->u.diadic.right = value;
+                IRO_Paste(list.head, list.tail, father3);
+                IRO_LocateFather_Cut_And_Paste_Without_Nopping(father2, add);
+                add->u.diadic.left = father2;
+                add->rtype = father2->rtype;
+                flag2 = 1;
+            }
+
+            if (!flag2) {
+                add->u.diadic.right = value;
+                add->u.diadic.right->flags |= IROLF_Reffed;
+                value->next = add;
+
+                add->u.diadic.left = nd;
+                IRO_LocateFather_Cut_And_Paste_Without_Nopping(nd, add);
+                add->flags |= IROLF_Reffed;
+
+                nd->next = value;
+                add->next = next;
+            }
+        }
+
+        if (nd == last)
+            break;
+    }
 }
 
-void UpdateInductionIncrement() {
+IROLinear *UpdateInductionIncrement(IROLoop *loop, SInt32 value, IROLinear *before) {
+    IROLinear *ind_nd;
+    IROLinear *addvalue;
+    IROLinear *ass;
+    Type *type;
+    ENode *expr;
+    IROList list;
+
+    IRO_InitList(&list);
+    ind_nd = loop->induction->nd;
+    type = ind_nd->rtype;
+
+    addvalue = IRO_NewLinear(IROLinearOperand);
+    addvalue->index = ++IRO_NumLinear;
+    addvalue->rtype = type;
+    expr = IRO_NewENode(EINTCONST);
+    expr->rtype = type;
+    CInt64_SetLong(&expr->data.intval, value * loop->induction->addConst);
+    addvalue->u.node = expr;
+    IRO_AddToList(addvalue, &list);
+
+    if (IS_LINEAR_MONADIC_2(ind_nd, EPREINC, EPOSTINC)) {
+        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+        ass = IRO_NewLinear(IROLinearOp2Arg);
+        ass->index = ++IRO_NumLinear;
+        ass->nodetype = EADDASS;
+        ass->u.diadic.left = ind_nd;
+        ass->u.diadic.right = addvalue;
+        ass->rtype = type;
+        IRO_AddToList(ass, &list);
+    } else if (IS_LINEAR_MONADIC_2(ind_nd, EPREDEC, EPOSTDEC)) {
+        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+        ass = IRO_NewLinear(IROLinearOp2Arg);
+        ass->index = ++IRO_NumLinear;
+        ass->nodetype = ESUBASS;
+        ass->u.diadic.left = ind_nd;
+        ass->u.diadic.right = addvalue;
+        ass->rtype = type;
+        IRO_AddToList(ass, &list);
+    } else if (IS_LINEAR_DIADIC(ind_nd, EADDASS)) {
+        ind_nd = IRO_DuplicateExpr(ind_nd->u.monadic, &list);
+
+        ass = IRO_NewLinear(IROLinearOp2Arg);
+        ass->index = ++IRO_NumLinear;
+        ass->nodetype = EADDASS;
+        ass->u.diadic.left = ind_nd;
+        ass->u.diadic.right = addvalue;
+        ass->rtype = type;
+        IRO_AddToList(ass, &list);
+    }
+
+    IRO_Paste(list.head, list.tail, before);
+    return list.tail;
 }
 
-void GenInitialAssignment() {
+void GenInitialAssignment(IROLoop *loop, Object *var, IROList *list) {
+    Type *type;
+    IROLinear *nd;
+
+    CError_ASSERT(3924, loop->nd14 && loop->nd14->type == IROLinearOp2Arg);
+
+    type = loop->induction->nd->rtype;
+
+    nd = IRO_NewLinear(IROLinearOp2Arg);
+    nd->index = ++IRO_NumLinear;
+    nd->nodetype = EASS;
+    nd->u.diadic.left = IRO_TempReference(var, list);
+    nd->u.diadic.right = IRO_DuplicateExpr(loop->nd14->u.diadic.right, list);
+    nd->rtype = type;
+    IRO_AddToList(nd, list);
 }
 
-void GenNewInduction() {
+void GenNewInduction(void) {
+    CError_FATAL(3941);
 }
diff --git a/compiler_and_linker/unsorted/IroUtil.c b/compiler_and_linker/unsorted/IroUtil.c
index 67edd4b..53e6733 100644
--- a/compiler_and_linker/unsorted/IroUtil.c
+++ b/compiler_and_linker/unsorted/IroUtil.c
@@ -956,10 +956,40 @@ void IRO_ReplaceReferenceWithNode(IROLinear *a, IROLinear *b) {
     }
 }
 
-void IRO_GetTemp(IROExpr *expr) {
+VarRecord *IRO_GetTemp(IROExpr *expr) {
+    expr->x8 = create_temp_object(expr->linear->rtype);
+    return IRO_FindVar(expr->x8, 1, 1);
 }
 
 IROLinear *IRO_AssignToTemp(IROExpr *expr) {
+    IROLinear *objref;
+    IROLinear *ind;
+    IROLinear *ass;
+
+    objref = IRO_NewLinear(IROLinearOperand);
+    objref->u.node = create_objectrefnode(expr->x8);
+    objref->rtype = objref->u.node->data.objref->type;
+    objref->index = ++IRO_NumLinear;
+    objref->flags |= IROLF_Reffed | IROLF_Assigned | IROLF_Ind;
+
+    ind = IRO_NewLinear(IROLinearOp1Arg);
+    ind->nodetype = EINDIRECT;
+    ind->rtype = expr->linear->rtype;
+    ind->u.monadic = objref;
+    ind->index = ++IRO_NumLinear;
+    ind->flags |= IROLF_Reffed | IROLF_Assigned;
+
+    ass = IRO_NewLinear(IROLinearOp2Arg);
+    ass->nodetype = EASS;
+    ass->u.diadic.left = ind;
+    ass->u.diadic.right = expr->linear;
+    ass->rtype = expr->linear->rtype;
+    ass->index = ++IRO_NumLinear;
+
+    objref->next = ind;
+    ind->next = ass;
+    IRO_PasteAfter(objref, ass, expr->linear);
+    return ass;
 }
 
 IROLinear *IRO_FindStart(IROLinear *linear) {
@@ -993,7 +1023,7 @@ void IRO_RemoveCommaNodeFromIR(void) {
             if (!linear)
                 break;
             if (linear->nodetype == ECOMMA) {
-                linear->u.diadic.left->flags &= ~IROLF_Reffed;
+                linear->u.diadic.left->flags = linear->u.diadic.left->flags & ~IROLF_Reffed;
                 IRO_LocateFather_Cut_And_Paste_Without_Nopping(linear, linear->u.diadic.right);
                 linear->type = IROLinearNop;
             }
@@ -1200,7 +1230,7 @@ IROLinear *IRO_NewIntConst(CInt64 val, Type *type) {
     return linear;
 }
 
-IROLinear *IRO_NewFloatConst(Float val, Type *type) {
+IROLinear *IRO_NewFloatConst(const Float val, Type *type) {
     ENode *node;
     IROLinear *linear;
 
@@ -1230,4 +1260,3 @@ void IRO_CheckForUserBreak(void) {
         IRO_LastUserBreakTick = COS_GetTicks();
     }
 }
-
diff --git a/compiler_and_linker/unsorted/IroVars.c b/compiler_and_linker/unsorted/IroVars.c
index a40656a..15e7e65 100644
--- a/compiler_and_linker/unsorted/IroVars.c
+++ b/compiler_and_linker/unsorted/IroVars.c
@@ -1113,7 +1113,7 @@ void IRO_ScalarizeClassDataMembers(void) {
         }
         if (nd->type == IROLinearAsm) {
             IAEffects effects;
-            int i;
+            SInt32 i;
             CodeGen_GetAsmEffects(nd->u.asm_stmt, &effects);
             for (i = 0; i < effects.numoperands; i++) {
                 if ((var = IRO_FindVar(effects.operands[i].object, 0, 1)))
diff --git a/compiler_and_linker/unsorted/LoopOptimization.c b/compiler_and_linker/unsorted/LoopOptimization.c
index 1c0b905..c2a360f 100644
--- a/compiler_and_linker/unsorted/LoopOptimization.c
+++ b/compiler_and_linker/unsorted/LoopOptimization.c
@@ -843,19 +843,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
     if (loop->unknownCondition == ELESS) {
         branchOpcode = PC_BF;
         if (loop->lowerType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = loop->lower;
             reg1 = addiInstr->args[2].data.reg.reg;
             value2 = absStep - 1 - loop->lower;
             mode = 0;
         } else if (loop->upperType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             value1 = loop->upper;
             reg1 = addiInstr->args[1].data.reg.reg;
             value2 = absStep - 1 + loop->upper;
             mode = 1;
         } else {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             reg1 = addiInstr->args[1].data.reg.reg;
             reg2 = addiInstr->args[2].data.reg.reg;
             value2 = absStep - 1;
@@ -864,19 +864,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
     } else if (loop->unknownCondition == ELESSEQU) {
         branchOpcode = PC_BT;
         if (loop->lowerType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             value1 = loop->lower;
             reg1 = addiInstr->args[2].data.reg.reg;
             value2 = absStep - loop->lower;
             mode = 0;
         } else if (loop->upperType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = loop->upper;
             reg1 = addiInstr->args[1].data.reg.reg;
             value2 = absStep + loop->upper;
             mode = 1;
         } else {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = 0;
             reg1 = addiInstr->args[1].data.reg.reg;
             reg2 = addiInstr->args[2].data.reg.reg;
@@ -886,19 +886,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
     } else if (loop->unknownCondition == EGREATER) {
         branchOpcode = PC_BF;
         if (loop->lowerType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             value1 = loop->lower;
             reg1 = addiInstr->args[2].data.reg.reg;
             value2 = absStep - 1 + loop->lower;
             mode = 1;
         } else if (loop->upperType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = loop->upper;
             reg1 = addiInstr->args[1].data.reg.reg;
             value2 = absStep - 1 - loop->upper;
             mode = 0;
         } else {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = 0;
             reg1 = addiInstr->args[1].data.reg.reg;
             reg2 = addiInstr->args[2].data.reg.reg;
@@ -908,19 +908,19 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
     } else if (loop->unknownCondition == EGREATEREQU) {
         branchOpcode = PC_BT;
         if (loop->lowerType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 1;
+            branchCondition = 1; // GT
             value1 = loop->lower;
             reg1 = addiInstr->args[2].data.reg.reg;
             value2 = absStep + loop->lower;
             mode = 1;
         } else if (loop->upperType == LOOP_BOUND_CONSTANT) {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             value1 = loop->upper;
             reg1 = addiInstr->args[1].data.reg.reg;
             value2 = absStep - loop->upper;
             mode = 0;
         } else {
-            branchCondition = 0;
+            branchCondition = 0; // LT
             reg1 = addiInstr->args[1].data.reg.reg;
             reg2 = addiInstr->args[2].data.reg.reg;
             value2 = absStep;
@@ -928,7 +928,7 @@ static void rewriteunknownloopwithBDNZ(Loop *loop) {
         }
     } else if (loop->unknownCondition == ENOTEQU) {
         branchOpcode = PC_BT;
-        branchCondition = 2;
+        branchCondition = 2; // EQ
         if (loop->step > 0) {
             if (loop->lowerType == LOOP_BOUND_CONSTANT) {
                 value1 = loop->lower;
diff --git a/compiler_and_linker/unsorted/RegisterInfo.c b/compiler_and_linker/unsorted/RegisterInfo.c
index a5e9966..91d775f 100644
--- a/compiler_and_linker/unsorted/RegisterInfo.c
+++ b/compiler_and_linker/unsorted/RegisterInfo.c
@@ -75,7 +75,7 @@ void retain_GPR_pair(Object *obj, short reg, short regHi) {
 }
 
 int is_register_object(Object *obj) {
-    return obj->sclass == OBJECT_SCLASS_101;
+    return obj->sclass == TK_REGISTER;
 }
 
 int GetABIFirstNonVolatile(RegClass rclass) {
@@ -118,10 +118,9 @@ void setup_diagnostic_reg_strings(void) {
 }
 
 void init_target_registers(void) {
-    RegClass rclass;
     int reg;
     int end;
-    int tmp;
+    RegClass rclass;
 
     static int last_nonvolatile_reg[] = {3, 5, 31, 31, 31};
     static int nonvol_reserve[] = {0, 0, 0, 4, 3};
@@ -153,8 +152,7 @@ void init_target_registers(void) {
             end = first_nonvolatile_reg(rclass);
             for (reg = last_nonvolatile_reg[rclass]; reg >= end; reg--) {
                 if (reg_state[rclass][reg] == RegState0) {
-                    tmp = n_nonvolatile_registers[rclass]++;
-                    nonvolatile_registers[rclass][tmp] = reg;
+                    nonvolatile_registers[rclass][n_nonvolatile_registers[rclass]++] = reg;
                 }
             }
         }
@@ -167,8 +165,7 @@ void init_target_registers(void) {
         for (reg = 0; reg < n_real_registers[rclass]; reg++) {
             if (reg < GetABIFirstNonVolatile(rclass) || reg > last_nonvolatile_reg[rclass]) {
                 if (reg_state[rclass][reg] == RegState0) {
-                    tmp = n_scratch_registers[rclass]++;
-                    scratch_registers[rclass][tmp] = reg;
+                    scratch_registers[rclass][n_scratch_registers[rclass]++] = reg;
                 }
             }
         }
@@ -250,9 +247,6 @@ void open_fe_temp_registers(void) {
     first_fe_temporary_register[RegClass_FPR] = last_temporary_register[RegClass_FPR] = r;
     r = used_virtual_registers[RegClass_VR];
     first_fe_temporary_register[RegClass_VR] = last_temporary_register[RegClass_VR] = r;
-    //first_fe_temporary_register[RegClass_GPR] = last_temporary_register[RegClass_GPR] = used_virtual_registers[RegClass_GPR];
-    //first_fe_temporary_register[RegClass_FPR] = last_temporary_register[RegClass_FPR] = used_virtual_registers[RegClass_FPR];
-    //first_fe_temporary_register[RegClass_VR] = last_temporary_register[RegClass_VR] = used_virtual_registers[RegClass_VR];
 }
 
 void set_last_exception_registers(void) {
@@ -371,14 +365,17 @@ void init_endian(void) {
 
 void update_asm_nonvolatile_registers(void) {
     RegClass rclass;
-    int r31;
+    int i;
+    int reg;
 
     for (rclass = 0; rclass < RegClassMax; rclass++) {
-        for (r31 = n_nonvolatile_registers[rclass] - 1; r31 >= 0; r31--) {
-            if (reg_state[rclass][nonvolatile_registers[rclass][r31]] == RegState1)
+        reg = n_nonvolatile_registers[rclass];
+        for (i = n_nonvolatile_registers[rclass] - 1; i >= 0; i--) {
+            if (reg_state[rclass][nonvolatile_registers[rclass][i]] == RegState1)
                 break;
+            reg--;
         }
-        if (r31 > used_nonvolatile_registers[rclass])
-            used_nonvolatile_registers[rclass] = r31;
+        if (reg > used_nonvolatile_registers[rclass])
+            used_nonvolatile_registers[rclass] = reg;
     }
 }
diff --git a/compiler_and_linker/unsorted/StackFrame.c b/compiler_and_linker/unsorted/StackFrame.c
index a78552d..91b15da 100644
--- a/compiler_and_linker/unsorted/StackFrame.c
+++ b/compiler_and_linker/unsorted/StackFrame.c
@@ -71,8 +71,8 @@ static void restore_nonvolatile_GPRs(int reg, SInt32 offset);
 static void do_allocate_dynamic_stack_space(Boolean isConstantSize, int reg1, int reg2, SInt32 size);
 
 void init_stack_globals(Object *funcobj) {
-    char rclass;
-    UInt8 oclass;
+    RegClass rclass;
+    ObjClass oclass;
 
     requires_frame = 0;
     makes_call = 0;
@@ -109,7 +109,7 @@ void init_stack_globals(Object *funcobj) {
     LR_save_offset = -1;
 
     for (rclass = 0; rclass < RegClassMax; rclass++)
-        non_volatile_save_offset[(char) rclass] = -1;
+        non_volatile_save_offset[rclass] = -1;
 
     dummyprofiler = NULL;
     dummyvaparam = NULL;
diff --git a/compiler_and_linker/unsorted/TOC.c b/compiler_and_linker/unsorted/TOC.c
index 49ae3e1..3fde61b 100644
--- a/compiler_and_linker/unsorted/TOC.c
+++ b/compiler_and_linker/unsorted/TOC.c
@@ -10,8 +10,12 @@
 #include "compiler/CMangler.h"
 #include "compiler/CParser.h"
 #include "compiler/CodeGen.h"
+#include "compiler/CompilerTools.h"
 #include "compiler/Exceptions.h"
+#include "compiler/InlineAsm.h"
+#include "compiler/InlineAsmPPC.h"
 #include "compiler/InstrSelection.h"
+#include "compiler/Intrinsics.h"
 #include "compiler/ObjGenMachO.h"
 #include "compiler/Operands.h"
 #include "compiler/PCode.h"
@@ -19,7 +23,6 @@
 #include "compiler/PPCError.h"
 #include "compiler/RegisterInfo.h"
 #include "compiler/StackFrame.h"
-#include "compiler/CompilerTools.h"
 #include "compiler/enode.h"
 #include "compiler/objects.h"
 #include "compiler/types.h"
@@ -27,10 +30,10 @@
 ObjectList *toclist;
 ObjectList *exceptionlist;
 void *descriptorlist;
-void *floatconstpool;
-void *doubleconstpool;
+PoolEntry *floatconstpool;
+PoolEntry *doubleconstpool;
 ObjectList *floatconstlist;
-void *vectorconstpool;
+PoolEntry *vectorconstpool;
 ObjectList *vectorconstlist;
 Object toc0;
 Boolean no_descriptors;
@@ -126,7 +129,7 @@ void createNonLazyPointer(Object *obj) {
     toc->toc = NULL;
     toc->section = SECT_NONLAZY_PTRS;
     toc->u.toc.info = CodeGen_GetNewVarInfo();
-    toc->sclass = OBJECT_SCLASS_102;
+    toc->sclass = TK_STATIC;
     toc->qual = Q_CONST;
     toc->datatype = DNONLAZYPTR;
     toc->flags |= OBJECT_FLAGS_2;
@@ -193,7 +196,7 @@ Object *createfloatconstant(Type *type, Float *data) {
     obj->toc = NULL;
     obj->u.data.info = NULL;
     obj->u.data.linkname = obj->name;
-    obj->sclass = OBJECT_SCLASS_102;
+    obj->sclass = TK_STATIC;
     obj->qual = Q_CONST | Q_10000;
     obj->datatype = DDATA;
     if (type->size == 8)
@@ -238,7 +241,7 @@ Object *createvectorconstant(Type *type, MWVector128 *data) {
     obj->toc = NULL;
     obj->u.data.info = NULL;
     obj->u.data.linkname = obj->name;
-    obj->sclass = OBJECT_SCLASS_102;
+    obj->sclass = TK_STATIC;
     obj->qual = Q_CONST | Q_10000;
     obj->datatype = DDATA;
     if (type->size == 16)
@@ -261,16 +264,153 @@ Object *createvectorconstant(Type *type, MWVector128 *data) {
     return obj;
 }
 
-void DeclarePooledConstants() {
-    // TODO CInit
+void DeclarePooledConstants(void) {
+    PoolEntry *entry;
+    char *buffer;
+    SInt32 fsize;
+    SInt32 dsize;
+    SInt32 vsize;
+
+    fsize = 0;
+    for (entry = floatconstpool; entry; entry = entry->next)
+        fsize += 4;
+
+    if (fsize) {
+        floatconstpool->object->type = CDecl_NewArrayType(TYPE(&stfloat), fsize);
+        buffer = galloc(fsize);
+        for (entry = floatconstpool; entry; entry = entry->next)
+            memcpy(buffer + entry->offset, entry->buffer, 4);
+        CInit_DeclareReadOnlyData(floatconstpool->object, buffer, NULL, fsize);
+    }
+
+    dsize = 0;
+    for (entry = doubleconstpool; entry; entry = entry->next)
+        dsize += 8;
+
+    if (dsize) {
+        doubleconstpool->object->type = CDecl_NewArrayType(TYPE(&stdouble), dsize);
+        buffer = galloc(dsize);
+        for (entry = doubleconstpool; entry; entry = entry->next)
+            memcpy(buffer + entry->offset, entry->buffer, 8);
+        CInit_DeclareReadOnlyData(doubleconstpool->object, buffer, NULL, dsize);
+    }
+
+    vsize = 0;
+    for (entry = vectorconstpool; entry; entry = entry->next)
+        vsize += 16;
+
+    if (vsize) {
+        vectorconstpool->object->type = CDecl_NewArrayType(TYPE(&stvectorsignedlong), vsize);
+        buffer = galloc(vsize);
+        for (entry = vectorconstpool; entry; entry = entry->next)
+            memcpy(buffer + entry->offset, entry->buffer, 16);
+        CInit_DeclareReadOnlyData(vectorconstpool->object, buffer, NULL, vsize);
+    }
 }
 
-static Object *CreatePooledFloatConst(Type *type, Float *data, SInt32 *unkptr) {
-    // TODO CDecl
+static Object *CreatePooledFloatConst(Type *type, Float *data, SInt32 *pOffset) {
+    if (type->size == 8u) {
+        PoolEntry *entry;
+        void *buffer;
+        Object *object;
+        SInt32 offset;
+
+        buffer = galloc(8u);
+        CMach_InitFloatMem(type, *data, buffer);
+        if (cparamblkptr->isPrecompiling == 1)
+            CError_Error(CErrorStr180);
+
+        for (entry = doubleconstpool; entry; entry = entry->next) {
+            if (!memcmp(entry->buffer, buffer, 8u))
+                break;
+        }
+
+        if (!entry) {
+            if (doubleconstpool) {
+                object = doubleconstpool->object;
+                offset = doubleconstpool->offset + 8u;
+                doubleconstpool->object->type->size += 8u;
+            } else {
+                DeclInfo di;
+                memclrw(&di, sizeof(di));
+                di.thetype = CDecl_NewArrayType(TYPE(&stdouble), 8u);
+                di.name = GetHashNameNodeExport("@doubleBase0");
+                di.qual = Q_CONST;
+                di.storageclass = TK_STATIC;
+                di.x4E = 1;
+                di.section = SECT_CONST;
+                object = CParser_NewGlobalDataObject(&di);
+                object->nspace = cscope_root;
+                offset = 0;
+            }
+
+            entry = galloc(sizeof(PoolEntry));
+            entry->next = doubleconstpool;
+            doubleconstpool = entry;
+            entry->object = object;
+            entry->offset = offset;
+            entry->buffer = galloc(8u);
+            memcpy(entry->buffer, buffer, 8u);
+        }
+
+        *pOffset = entry->offset;
+        return entry->object;
+    }
+
+    if (type->size == 4u) {
+        PoolEntry *entry;
+        void *buffer;
+        Object *object;
+        SInt32 offset;
+
+        buffer = galloc(4u);
+        CMach_InitFloatMem(type, *data, buffer);
+        if (cparamblkptr->isPrecompiling == 1)
+            CError_Error(CErrorStr180);
+
+        for (entry = floatconstpool; entry; entry = entry->next) {
+            if (!memcmp(entry->buffer, buffer, 4u))
+                break;
+        }
+
+        if (!entry) {
+            if (floatconstpool) {
+                object = floatconstpool->object;
+                offset = floatconstpool->offset + 4u;
+                object->type->size += 4u;
+            } else {
+                DeclInfo di;
+                memclrw(&di, sizeof(di));
+                di.thetype = CDecl_NewArrayType(TYPE(&stfloat), 4u);
+                di.name = GetHashNameNodeExport("@floatBase0");
+                di.qual = Q_CONST;
+                di.storageclass = TK_STATIC;
+                di.x4E = 1;
+                di.section = SECT_CONST;
+                object = CParser_NewGlobalDataObject(&di);
+                object->nspace = cscope_root;
+                offset = 0;
+            }
+
+            entry = galloc(sizeof(PoolEntry));
+            entry->next = floatconstpool;
+            floatconstpool = entry;
+            entry->object = object;
+            entry->offset = offset;
+            entry->buffer = galloc(4u);
+            memcpy(entry->buffer, buffer, 4u);
+        }
+
+        *pOffset = entry->offset;
+        return entry->object;
+    }
+
+    CError_FATAL(1183);
+    return NULL;
 }
 
-Object *CreateFloatConst(Type *type, Float *data, SInt32 *unkptr) {
-    *unkptr = 0;
+Object *CreateFloatConst(Type *type, Float *data, SInt32 *pOffset) {
+    *pOffset = 0;
     return createfloatconstant(type, data);
 }
 
@@ -281,7 +421,7 @@ static void RewriteFloatConst(ENode *expr) {
 
     obj = CreateFloatConst(expr->rtype, &expr->data.floatval, &n);
     if (n) {
-        subexpr = makediadicnode(create_objectrefnode(obj), intconstnode(&stunsignedlong, n), EADD);
+        subexpr = makediadicnode(create_objectrefnode(obj), intconstnode(TYPE(&stunsignedlong), n), EADD);
     } else {
         subexpr = create_objectrefnode(obj);
     }
@@ -293,8 +433,63 @@ static void RewriteFloatConst(ENode *expr) {
 }
 
 static void RewriteVectorConst(ENode *expr) {
+    PoolEntry *entry;
+    Object *object;
+    SInt32 offset;
+    ENode *inner;
     UInt8 data[16];
-    // TODO
+
+    CMach_InitVectorMem(expr->rtype, expr->data.vector128val, data, 1);
+
+    if (cparamblkptr->isPrecompiling == 1)
+        CError_Error(CErrorStr180);
+
+    for (entry = vectorconstpool; entry; entry = entry->next) {
+        if (!memcmp(entry->buffer, data, 16))
+            break;
+    }
+
+    if (!entry) {
+        if (vectorconstpool) {
+            object = vectorconstpool->object;
+            offset = vectorconstpool->offset + 16;
+            vectorconstpool->object->type->size += 16;
+        } else {
+            DeclInfo di;
+            memclrw(&di, sizeof(di));
+            di.thetype = CDecl_NewArrayType(TYPE(&stvectorsignedlong), 16);
+            di.name = GetHashNameNodeExport("@vectorBase0");
+            di.qual = Q_CONST;
+            di.storageclass = TK_STATIC;
+            di.x4E = 1;
+            di.section = SECT_CONST;
+            object = CParser_NewGlobalDataObject(&di);
+            object->nspace = cscope_root;
+            offset = 0;
+        }
+
+        entry = galloc(sizeof(PoolEntry));
+        entry->next = vectorconstpool;
+        vectorconstpool = entry;
+        entry->object = object;
+        entry->offset = offset;
+        entry->buffer = galloc(16);
+        memcpy(entry->buffer, data, 16);
+    }
+
+    if (entry->offset) {
+        inner = makediadicnode(
+            create_objectrefnode(entry->object),
+            intconstnode(TYPE(&stunsignedlong), entry->offset),
+            EADD);
+    } else {
+        inner = create_objectrefnode(entry->object);
+    }
+
+    expr->type = EINDIRECT;
+    expr->cost = 1;
+    expr->flags |= ENODE_FLAG_CONST;
+    expr->data.monadic = inner;
 }
 
 static Object *createcodelabel(CLabel *label) {
@@ -313,7 +508,7 @@ static Object *createcodelabel(CLabel *label) {
     obj->name = label->uniquename;
     obj->toc = NULL;
     obj->u.data.info = NULL; // not sure if this is the right union!
-    obj->sclass = OBJECT_SCLASS_102;
+    obj->sclass = TK_STATIC;
     obj->qual = Q_CONST;
     obj->datatype = DDATA;
     obj->flags |= OBJECT_FLAGS_2 | OBJECT_FLAGS_4;
@@ -748,9 +943,13 @@ Boolean canoptimizevectorconst(MWVector128 *vecp, Type *type, COVCResult *result
 
         first8 = vec.sc[0];
         flag = 1;
-        for (i = 0; flag && i < 16; i++) {
+        i = 1;
+        while (flag && i < 16)
+            flag = first8 == vec.sc[i++];
+        /*flag = 1;
+        for (i = 1; flag && i < 16; i++) {
             flag = first8 == vec.sc[i];
-        }
+        }*/
 
         if (flag && first8 < 16 && first8 > -17) {
             if (result) {
@@ -954,6 +1153,12 @@ static Boolean DetectCondSideAffect(ENode *expr) {
         case EXOR:
         case EOR:
         case ECOMMA:
+        case EPMODULO:
+        case EROTL:
+        case EROTR:
+        case EBCLR:
+        case EBTST:
+        case EBSET:
             if (DetectCondSideAffect(expr->data.diadic.left))
                 return 1;
             return DetectCondSideAffect(expr->data.diadic.right);
@@ -961,7 +1166,7 @@ static Boolean DetectCondSideAffect(ENode *expr) {
             if (expr->data.monadic->type == EINDIRECT)
                 return 1;
             if (expr->data.monadic->type == EOBJREF) {
-                if (expr->data.monadic->data.objref->datatype != DDATA && expr->data.monadic->data.objref->datatype != DLOCAL)
+                if (expr->data.monadic->data.objref->datatype != DLOCAL && expr->data.monadic->data.objref->datatype != DDATA)
                     return 1;
                 if (IS_TYPE_POINTER(expr->data.monadic->data.objref->type))
                     return 1;
@@ -1509,12 +1714,12 @@ static void expandTOCexpression(ENode *expr, Type *type, int ignored) {
         case EFUNCCALLP:
             if (is_intrinsic_function_call(expr)) {
                 expr->hascall = 0;
-                if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_8) {
+                if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_008) {
                     if (copts.altivec_model)
                         update_frame_align(16);
                     dynamic_stack = 1;
                     requires_frame = 1;
-                } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_35) {
+                } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_035) {
                     if (expr->data.funccall.args->next->node->type == ESTRINGCONST) {
                         rewritestrcpy(expr);
                     } else {
@@ -1522,7 +1727,7 @@ static void expandTOCexpression(ENode *expr, Type *type, int ignored) {
                         makes_call = 1;
                         expr->hascall = 1;
                     }
-                } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == INTRINSIC_36) {
+                } else if ((expr->data.funccall.funcref->data.objref->u.func.u.intrinsicid & 0xFFFFu) == Intrinsic_036) {
                     if (expr->data.funccall.args->next->next->node->type != EINTCONST) {
                         requires_frame = 1;
                         makes_call = 1;
@@ -1929,6 +2134,10 @@ static void checkexceptionreferences(ExceptionAction *action) {
 
 void expandTOCreferences(Statement **stmts) {
     Statement *stmt;
+    IAOperand *op;
+    int i;
+    InlineAsm *ia;
+    VarInfo *vi;
 
     codelabellist = NULL;
     exceptionlist = NULL;
@@ -1952,7 +2161,7 @@ void expandTOCreferences(Statement **stmts) {
                 break;
             case ST_IFGOTO:
             case ST_IFNGOTO:
-                if (stmt->expr->type >= ELESS && stmt->expr->type <= ENOTEQU)
+                if (stmt->expr->type < ELESS || stmt->expr->type > ENOTEQU)
                     stmt->expr = comparewithzero(stmt->expr);
                 expandTOCexpression(stmt->expr, NULL, 0);
                 break;
@@ -1973,8 +2182,29 @@ void expandTOCreferences(Statement **stmts) {
                 makes_call = 1;
                 break;
             case ST_ASM:
-                if (stmt->expr) {
-                    // TODO - ASM weirdness here
+                if ((ia = (InlineAsm *) stmt->expr)) {
+                    if (ia->flags & IAFlag1) {
+                        if (ia->opcode == IADirective_FrFree)
+                            requires_frame = 1;
+                    } else {
+                        for (i = 0, op = ia->args; i < ia->argcount; i++, op++) {
+                            if (op->type == IAOpnd_Reg) {
+                                if (!op->u.reg.object) {
+                                    if (op->u.reg.num == INVALID_PIC_REG)
+                                        uses_globals = 1;
+                                    else if (op->u.reg.effect & EffectWrite)
+                                        asm_used_register(op->u.reg.rclass, op->u.reg.num);
+                                } else if ((vi = Registers_GetVarInfo(op->u.reg.object))) {
+                                    vi->flags |= VarInfoFlag40;
+                                }
+                            } else if (op->type == IAOpnd_3) {
+                                uses_globals = 1;
+                            }
+                        }
+
+                        if (ia->flags & IAFlag2)
+                            makes_call = 1;
+                    }
                 }
                 break;
         }
@@ -2021,7 +2251,7 @@ Object *createstaticinitobject(void) {
     obj->otype = OT_OBJECT;
     obj->type = (Type *) tfunc;
     obj->name = GetHashNameNodeExport(buf);
-    obj->sclass = OBJECT_SCLASS_102;
+    obj->sclass = TK_STATIC;
     obj->datatype = DFUNC;
 
     return obj;