     private func shareStepImage(stepIndex:Int)
     {
         let step:MLinearEquationsSolutionStep = model.steps[stepIndex]
+        let equationsCount:CGFloat = CGFloat(step.equations.count)
+        let equationsHeight:CGFloat = equationsCount * kCellHeight
         let collectionView:VCollection = viewSolution.collectionView
         let contentWidth:CGFloat = collectionView.contentSize.width
-        let exportbleHeight:CGFloat = originalSize.height - removeSize
-        let exporableSize:CGSize = CGSize(
+        let headerHeight:CGFloat = step.headerHeight
+        let contentHeight:CGFloat = headerHeight + equationsHeight
+        let exportableSize:CGSize = CGSize(
+            width:contentWidth,
+            height:contentHeight)
+        let frame:CGRect = CGRect(origin:CGPoint.zero, size:exportableSize)
+        
+        UIGraphicsBeginImageContextWithOptions(exportableSize, true, 0)
+        
+        guard
+            
+            let context:CGContext = UIGraphicsGetCurrentContext()
+            
+        else
+        {
+            return
+        }
+        
+        context.setFillColor(UIColor.white.cgColor)
+        context.fill(frame)
+        
+        let sectionPath:IndexPath = IndexPath(
+            item:0,
+            section:stepIndex)
+        let header:VLinearEquationsSolutionHeader = collectionView.dequeueReusableSupplementaryView(
+            ofKind:UICollectionElementKindSectionHeader,
+            withReuseIdentifier:
+            step.reusableIdentifier,
+            for:sectionPath) as! VLinearEquationsSolutionHeader
+        header.config(
+            step:step,
+            indexPath:sectionPath)
+        let removeFromTop:CGFloat = header.frame.minY
+        let headerFrame:CGRect = CGRect(
+            x:0,
+            y:0,
+            width:contentWidth,
+            height:headerHeight)
+        
+        header.drawHierarchy(
+            in:headerFrame,
+            afterScreenUpdates:true)
+        
+        var itemIndex:Int = 0
+        
+        for item:MLinearEquationsSolutionEquationItem in step.plainItems
+        {
+            let indexPath:IndexPath = IndexPath(
+                item:itemIndex,
+                section:stepIndex)
+            let cell:VLinearEquationsSolutionCell = collectionView.dequeueReusableCell(
+                withReuseIdentifier:
+                item.reusableIdentifier,
+                for:indexPath) as! VLinearEquationsSolutionCell
+            cell.config(
+                model:item,
+                index:indexPath)
+            let cellFrame:CGRect = cell.frame
+            let exportableCellFrame:CGRect = cellFrame.offsetBy(
+                dx:0,
+                dy:-removeFromTop)
+            cell.drawHierarchy(
+                in:exportableCellFrame,
+                afterScreenUpdates:true)
+            
+            itemIndex += 1
+        }
+        
+        guard
+            
+            let image:UIImage = UIGraphicsGetImageFromCurrentImageContext()
+            
+        else
+        {
+            UIGraphicsEndImageContext()
+            return
+        }
+        
+        UIGraphicsEndImageContext()
+        let sharingItems:[Any] = [image]
+        
+        share(items:sharingItems)
+        viewSolution.endExporting()
+    }
+    
+    private func shareSolutionImage()
+    {
+        let allFooters:CGFloat = CGFloat(model.steps.count)
+        let allFootersHeight:CGFloat = allFooters * kFooterHeight
+        let removeSize:CGFloat = kBarHeight + allFootersHeight
+        let collectionView:VCollection = viewSolution.collectionView
+        let originalSize:CGSize = collectionView.contentSize
+        let exportableHeight:CGFloat = originalSize.height - removeSize
+        let exportableSize:CGSize = CGSize(
             width:originalSize.width,
-            height:exportbleHeight)
-        let frame:CGRect = CGRect(origin:CGPoint.zero, size:exporableSize)
-        
-        UIGraphicsBeginImageContextWithOptions(exporableSize, true, 0)
+            height:exportableHeight)
+        let frame:CGRect = CGRect(origin:CGPoint.zero, size:exportableSize)
+        
+        UIGraphicsBeginImageContextWithOptions(exportableSize, true, 0)
         
         guard
             
             let context:CGContext = UIGraphicsGetCurrentContext()
             
-            else
+        else
         {
             return
         }

            style:
            UIAlertActionStyle.default)
        { [weak self] (action:UIAlertAction) in
            
        }
        
        let actionText:UIAlertAction = UIAlertAction(

            
            let image:UIImage = UIGraphicsGetImageFromCurrentImageContext()
            
        else
        {
            UIGraphicsEndImageContext()
