diff --git a/cif/CIFgen.c b/cif/CIFgen.c
index d063a087..7233d12f 100644
--- a/cif/CIFgen.c
+++ b/cif/CIFgen.c
@@ -842,6 +842,35 @@ endbloat:
     return 0;
 }
 
+/*
+ *-------------------------------------------------------
+ *
+ * cifFoundFun --
+ *
+ *	Find the first tile in the given area.
+ *
+ * Results:
+ *	Return 1 to stop the search and process.
+ *	Set clientData to the tile found.
+ *
+ *-------------------------------------------------------
+ */
+
+int
+cifFoundFunc(tile, treturn)
+    Tile *tile;
+    Tile **treturn;
+{
+    *treturn = tile;
+    return 1;
+}
+
+/* Data structure for bloat-all function */
+typedef struct _bloatStruct {
+    CIFOp	*op;
+    CellDef	*def;
+} BloatStruct;
+
 /*
  * ----------------------------------------------------------------------------
  *
@@ -873,18 +902,26 @@ endbloat:
     }
 
 int
-cifBloatAllFunc(tile, op)
+cifBloatAllFunc(tile, bls)
     Tile *tile;			/* The tile to be processed. */
-    CIFOp *op;			/* Describes the operation to be performed */
+    BloatStruct *bls;
 {
     Rect area;
     TileTypeBitMask connect;
     Tile *t, *tp;
     TileType type;
-    BloatData *bloats = (BloatData *)op->co_client;
+    BloatData *bloats;
     int i;
+    PlaneMask pmask;
+    int pNum;
+    CIFOp *op;
+    CellDef *def;
     static Stack *BloatStack = (Stack *)NULL;
 
+    op = bls->op;
+    def = bls->def;
+    bloats = (BloatData *)op->co_client;
+
     /* Create a mask of all connecting types (these must be in a single
      * plane), then call a search function to find all connecting material
      * of these types.
@@ -900,7 +937,24 @@ cifBloatAllFunc(tile, op)
     if (BloatStack == (Stack *)NULL)
 	BloatStack = StackNew(64);
 
-    PUSHTILE(tile, BloatStack);
+    /* If the type of the tile to be processed is not in the same plane	*/
+    /* as the bloat type(s), then find any tile under the tile to be	*/
+    /* processed that belongs to the connect mask, and use that as the	*/
+    /* starting tile.							*/
+
+    t = tile;
+    type = TiGetType(tile);
+    pNum = DBPlane(type);
+    pmask = CoincidentPlanes(&connect, pNum);
+    if (pmask == 0)
+    {
+	TiToRect(tile, &area);
+	if (DBSrPaintArea((Tile *)NULL, def->cd_planes[bloats->bl_plane], &area,
+		&connect, cifFoundFunc, (ClientData)(&t)) == 0)
+	    return 0;	    /* Nothing found here */
+    }
+
+    PUSHTILE(t, BloatStack);
     while (!StackEmpty(BloatStack))
     {
 	t = (Tile *) STACKPOP(BloatStack);
@@ -2688,6 +2742,7 @@ cifSrTiles(cifOp, area, cellDef, temps, func, cdArg)
 {
     TileTypeBitMask maskBits;
     TileType t;
+    Tile *tp;
     int i;
     BloatData *bloats;
 
@@ -2699,7 +2754,7 @@ cifSrTiles(cifOp, area, cellDef, temps, func, cdArg)
 
     cifScale = (CIFCurStyle) ? CIFCurStyle->cs_scaleFactor : 1;
 
-    /* Bloat operations have to be in a single plane */
+    /* Bloat operations (except bloat-all) have to be in a single plane */
 
     switch (cifOp->co_opcode) {
 	case CIFOP_BLOAT:
@@ -2783,6 +2838,7 @@ CIFGenLayer(op, area, cellDef, temps, clientdata)
     SearchContext scx;
     TileType ttype;
     char *netname;
+    BloatStruct bls;
     int (*cifGrowFuncPtr)() = (CIFCurStyle->cs_flags & CWF_GROW_EUCLIDEAN) ?
 		cifGrowEuclideanFunc : cifGrowFunc;
 
@@ -2971,8 +3027,10 @@ CIFGenLayer(op, area, cellDef, temps, clientdata)
 
 	    case CIFOP_BLOATALL:
 		cifPlane = curPlane;
+		bls.op = op;
+		bls.def = cellDef;
 		cifSrTiles(op, area, cellDef, temps,
-		    cifBloatAllFunc, (ClientData) op);
+		    cifBloatAllFunc, (ClientData)&bls);
 		break;
 	    
 	    case CIFOP_SQUARES:
diff --git a/cif/CIFint.h b/cif/CIFint.h
index 6d3ef7ba..c9280e12 100644
--- a/cif/CIFint.h
+++ b/cif/CIFint.h
@@ -310,6 +310,7 @@ extern void CIFLoadStyle();
 extern Plane *CIFPlanes[];		/* Normal place to store CIF. */
 extern CIFKeep *CIFStyleList;		/* List of all CIF styles. */
 extern CIFStyle *CIFCurStyle;		/* Current style being used. */
+extern CIFStyle *CIFDRCStyle;		/* CIF style for DRC checking (optional) */
 extern CellUse *CIFComponentUse;	/* Flatten stuff in here if needed. */
 extern CellDef *CIFComponentDef;	/* Corresponds to CIFComponentUse. */
 extern CellUse *CIFDummyUse;		/* Used to dummy up a CellUse for a
diff --git a/cif/CIFtech.c b/cif/CIFtech.c
index 54bb05c6..25a920e3 100644
--- a/cif/CIFtech.c
+++ b/cif/CIFtech.c
@@ -1081,13 +1081,17 @@ CIFTechLine(sectionName, argc, argv)
 	    if (argc != 3) goto wrongNumArgs;
 	    cifParseLayers(argv[1], CIFCurStyle, &newOp->co_paintMask,
 		(TileTypeBitMask *)NULL, FALSE);
-	    bloatLayers = newOp->co_paintMask;
 	    bloats = (BloatData *)mallocMagic(sizeof(BloatData));
 	    for (i = 0; i < TT_MAXTYPES; i++)
 		bloats->bl_distance[i] = 0;
 	    newOp->co_client = (ClientData)bloats;
-
 	    cifParseLayers(argv[2], CIFCurStyle, &mask, &tempMask, TRUE);
+
+	    /* 10/15/2019:  Lifting restriction that the types that	*/
+	    /* trigger the bloating must be in the same plane as the	*/
+	    /* types that are bloated into.				*/
+
+	    TTMaskZero(&bloatLayers);
 	    TTMaskSetMask(&bloatLayers, &mask);
 	    if (!TTMaskEqual(&tempMask, &DBZeroTypeBits))
 		TechError("Can't use templayers in bloat statement.\n");
@@ -1945,7 +1949,7 @@ CIFLoadStyle(stylename)
 {
     SectionID invcif;
 
-    if (CIFCurStyle->cs_name == stylename) return;
+    if (CIFCurStyle && (CIFCurStyle->cs_name == stylename)) return;
 
     cifTechNewStyle();
     CIFCurStyle->cs_name = stylename;
diff --git a/drc/DRCcif.c b/drc/DRCcif.c
index b4344620..fa4f00c7 100644
--- a/drc/DRCcif.c
+++ b/drc/DRCcif.c
@@ -67,9 +67,10 @@ extern bool DRCForceReload;
 TileTypeBitMask drcCifGenLayers;
 
 DRCCookie *drcCifRules[MAXCIFLAYERS][2];
-DRCCookie *drcCifCur=NULL;
+DRCCookie *drcCifCur = NULL;
 int	drcCifValid = FALSE;
-int	beenWarned;
+bool	beenWarned = FALSE;
+char	*drcNeedStyle = NULL;
 
 #define DRC_CIF_SPACE		0
 #define DRC_CIF_SOLID		1
@@ -112,14 +113,12 @@ drcCifSetStyle(argc, argv)
     {
 	if (!strcmp(new->cs_name, argv[1]))
 	{
+	    drcNeedStyle = new->cs_name;
 	    DRCForceReload = TRUE;
 	    if (!strcmp(new->cs_name, CIFCurStyle->cs_name))
 		drcCifStyle = CIFCurStyle;
 	    else
 	    {
-		TechError("DRC cif extensions are not enabled.\n\t"
-			"Use \"cif ostyle %s\" to enable them.\n",
-			new->cs_name);
 		drcCifStyle = NULL;
 		beenWarned = TRUE;	/* post no more error messages */
 	    }
@@ -501,9 +500,35 @@ drcCifCheck(arg)
     int		scale;
     int		i,j;
     int		oldTiles;
+    CIFStyle	*CIFSaveStyle = NULL;
 
+    if (CIFCurStyle != drcCifStyle)
+    {
+	if (drcNeedStyle == NULL) {
+	    TxError("Error:  No DRC CIF style declared!\n");
+	    return;
+	}
+
+	CIFSaveStyle = CIFCurStyle;
+
+	if (drcCifStyle == NULL)
+	{
+	    TxPrintf("Loading DRC CIF style.\n");
+	    CIFCurStyle = NULL;
+	    CIFLoadStyle(drcNeedStyle);
+	    if (drcCifValid == FALSE)
+		CIFCurStyle = CIFSaveStyle;
+	    else
+		drcCifStyle = CIFCurStyle;
+	}
+	if (drcCifStyle == NULL)
+	{
+	    TxError("Error:  Failed to load CIF DRC style.\n");
+	    return;
+	}
+	CIFCurStyle = drcCifStyle;
+    }
     if (drcCifValid == FALSE) return;
-    else if (CIFCurStyle != drcCifStyle) return;
 
     scale = drcCifStyle->cs_scaleFactor;
     cifrect = *checkRect;
@@ -534,6 +559,9 @@ drcCifCheck(arg)
      }
      arg->dCD_rect = checkRect;
      DRCstatCifTiles += DRCstatTiles - oldTiles;
+
+     /* Put it back the way you found it */
+     if (CIFSaveStyle != NULL) CIFCurStyle = CIFSaveStyle;
 }
 
 /*