COMPARISON

Iron Suite vs MESCIUS Document Solutions

At {{mescius_document_solutions.bundle_developer}} per developer/year for the Document Solutions .NET Bundle entry tier versus $2,998 for the perpetual Iron Suite Lite license, the dollar baseline alone reframes the procurement question. MESCIUS sells four core .NET libraries (DsPdf, DsExcel, DsWord, DsImaging) on an annual subscription, with royalty-free deployment unlocked only at the Unlimited tier and viewer SKUs sold separately. Iron Suite ships ten Iron Software products in one perpetual per-developer bundle, royalty-free for licensed seats out of the box, with SaaS and OEM redistribution covered by a single Redistribution Add-On.

This comparison leads with what a procurement-led decision actually hangs on: how each suite is priced over a license cycle, what the bundle covers, and how redistribution is handled. The capability detail and code follow below for the engineers who'll ship it.

At-a-Glance Comparison

DimensionDocument Solutions for .NETIron Suite
Pricing positioning.NET Bundle: Developer {{mescius_document_solutions.bundle_developer}} / Developer Unlimited {{mescius_document_solutions.bundle_developer_unlimited}} / Team Unlimited {{mescius_document_solutions.bundle_team_unlimited_5dev}} (5 devs). Individual products: {{mescius_document_solutions.individual_standard}}/{{mescius_document_solutions.individual_unlimited}}/{{mescius_document_solutions.individual_team_unlimited_5dev}}Lite $2,998 / Plus $4,498 / Professional $8,998 / Unlimited $17,998 (Enterprise custom). All 10 products for the price of 2, save 75%
License modelPer-developer annual subscription with 1-yr maintenance and support; royalty-free deployment at Unlimited tier; reduced renewal ratesPerpetual per-developer; royalty-free for licensed seats; SaaS/OEM via Redistribution Add-On
Components in bundle4 core .NET libraries (DsPdf, DsExcel, DsWord, DsImaging) + 3 viewer SKUs sold separately10 products (IronPDF, IronWord, IronXL, IronPPT, IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, IronWebScraper)
Format / capability coveragePDF, Excel, Word, Imaging + viewer familyPDF, Office, OCR, Barcode/QR, ZIP, Print, Web Scraping
Cross-platform / cloudWindows, macOS, Linux, Azure, AWS, AWS LambdaWindows, Linux, macOS, Docker, Azure, AWS Lambda
.NET runtime support.NET Standard 2.0 (covers .NET Framework 4.6.2+, .NET Core 2.0+, .NET 6/7/8 formally supported; .NET 9/10 via computed target compatibility).NET Framework 4.6.2+, .NET Core, .NET 6/7/8/9
Target marketEnterprise and ISV .NET teams; financial services and reporting-heavy verticalsIndependent developers, SMB, mid-market .NET teams, ISVs
VendorMESCIUS inc. (formerly GrapeCity)Iron Software

The headline contrast is around bundle breadth and recognition. Document Solutions covers PDF, Excel, Word, and Imaging deeply but does not include OCR, barcode, QR, web scraping, or print. Iron Suite covers all of those at a lower entry price (~$2,998 vs the {{mescius_document_solutions.bundle_developer}} MESCIUS .NET Bundle entry tier).

Pricing and Licensing

Document Solutions for .NET uses a per-developer annual subscription model with three license tiers per SKU. For the .NET Bundle: Developer License at {{mescius_document_solutions.bundle_developer}}/developer, Developer Unlimited at {{mescius_document_solutions.bundle_developer_unlimited}}/developer, and Team Unlimited at {{mescius_document_solutions.bundle_team_unlimited_5dev}} for 5 developers. Individual products (DsPdf, DsExcel, DsWord, DsImaging) follow the same matrix at {{mescius_document_solutions.individual_standard}}/{{mescius_document_solutions.individual_unlimited}}/{{mescius_document_solutions.individual_team_unlimited_5dev}}. Each license includes 1-year Annual Maintenance & Support, and renewals are at reduced rates (annual renewal pricing available from MESCIUS vs {{mescius_document_solutions.individual_standard}} initial for the individual product Developer tier). Royalty-free deployment is included at the Unlimited tier.

Iron Suite is sold as a single perpetual per-developer license at five tier levels (Lite, Plus, Professional, Unlimited, and Enterprise) starting from $2,998, with the marketing positioning of "all 10 products for the price of 2, save 75%." The base license is royalty-free for the licensed seats, locations, or projects, and SaaS, OEM, or distributed redistribution beyond the base license uses a single, separately priced Redistribution Add-On.

The contrast: Document Solutions has clean public pricing but is subscription-based and covers a smaller bundle. Iron Suite is perpetual, covers a broader bundle, and starts at a lower entry price.

What is Document Solutions for .NET

Document Solutions for .NET is the rebranded GrapeCity Documents product family, now published by MESCIUS inc. (the 2023 rebrand of GrapeCity). The .NET catalogue currently includes Document Solutions for PDF (DsPdf), Excel (DsExcel), Word (DsWord), and Imaging (DsImaging), plus a separate Document Solutions PDF Viewer / Data Viewer / Image Viewer family for embedded UI scenarios. The libraries target .NET Standard 2.0, giving broad runtime coverage from .NET Framework 4.6.2+ through .NET Core 2.0+ and modern .NET 6/7/8 (formally supported); .NET 9/10 via computed target compatibility. NuGet packages now ship under DS.Documents.*, but in-code namespaces remain GrapeCity.Documents.* for backward compatibility. The latest reference release is DS.Documents.Pdf 9.1.0, published 2026-05-04.

Key bundled components and capabilities:

  • Document Solutions for PDF (DsPdf): fluent code-first PDF generation with a real text-layout engine
  • Document Solutions for Excel (DsExcel): fast XLSX engine with 450+ built-in functions
  • Document Solutions for Word (DsWord): DOCX creation and manipulation with a similar fluent style
  • Document Solutions for Imaging (DsImaging): cross-platform image processing primitives
  • PDF Viewer / Data Viewer / Image Viewer: embedded UI components (priced separately)
  • Sister Java and JS editions: DsPdf JS, DsExcel Java for cross-language parity

What is Iron Suite

Iron Suite for .NET is the bundle published by Iron Software that packages all ten Iron Software products into one perpetual per-developer license, marketed as "all 10 products for the price of 2, save 75%" with licenses starting from $2,998. The suite is aimed at .NET developers and ISVs who want a single, idiomatic, code-first toolkit for everyday document workloads: PDF rendering, Word/Excel/PPT manipulation, OCR, barcode and QR, web scraping, ZIP, and programmatic printing. The components run on .NET Framework 4.6.2+ and modern .NET (6/7/8/9) across Windows, Linux, macOS, Docker, Azure, and AWS.

The ten bundled products:

  • IronPDF: HTML-to-PDF rendering, PDF editing, signing, merging
  • IronWord: DOCX creation and manipulation
  • IronXL: Excel read/write with formula calculation
  • IronPPT: PowerPoint creation and editing
  • IronOCR: Tesseract-based OCR with image preprocessing
  • IronBarcode: 1D/2D barcode read and write
  • IronQR: Dedicated QR code library
  • IronPrint: Programmatic printing
  • IronZIP: ZIP archive creation and extraction
  • IronWebScraper: Web scraping and content extraction

Capability Comparison

PDF Generation (Fluent Code-First vs HTML-First)

PDF generation style is where the two suites diverge most. DsPdf is the signature MESCIUS strength: a fluent code-first PDF layout API with GcPdfDocument, GcPdfGraphics, and a real text-layout engine. IronPDF renders PDFs from HTML using a real Chrome engine.

// DsPdf builds PDFs with a fluent code-first layout API — the defining strength of Document Solutions.
// NuGet: Install-Package DS.Documents.Pdf
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Text;
using System.Drawing;

class Program
{
    static void Main()
    {
        GcPdfDocument doc = new GcPdfDocument();
        GcPdfGraphics g = doc.NewPage().Graphics;

        TextFormat title = new TextFormat { Font = StandardFonts.HelveticaBold, FontSize = 20 };
        g.DrawString("Statement of Account", title, new PointF(72, 72));

        TextFormat body = new TextFormat { Font = StandardFonts.Helvetica, FontSize = 11 };
        g.DrawString("Generated 2026-05-26 — fluent code-first layout.", body, new PointF(72, 110));

        doc.Save("statement.pdf");
    }
}
// DsPdf builds PDFs with a fluent code-first layout API — the defining strength of Document Solutions.
// NuGet: Install-Package DS.Documents.Pdf
using GrapeCity.Documents.Pdf;
using GrapeCity.Documents.Text;
using System.Drawing;

class Program
{
    static void Main()
    {
        GcPdfDocument doc = new GcPdfDocument();
        GcPdfGraphics g = doc.NewPage().Graphics;

        TextFormat title = new TextFormat { Font = StandardFonts.HelveticaBold, FontSize = 20 };
        g.DrawString("Statement of Account", title, new PointF(72, 72));

        TextFormat body = new TextFormat { Font = StandardFonts.Helvetica, FontSize = 11 };
        g.DrawString("Generated 2026-05-26 — fluent code-first layout.", body, new PointF(72, 110));

        doc.Save("statement.pdf");
    }
}
Imports GrapeCity.Documents.Pdf
Imports GrapeCity.Documents.Text
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim doc As New GcPdfDocument()
        Dim g As GcPdfGraphics = doc.NewPage().Graphics

        Dim title As New TextFormat With {
            .Font = StandardFonts.HelveticaBold,
            .FontSize = 20
        }
        g.DrawString("Statement of Account", title, New PointF(72, 72))

        Dim body As New TextFormat With {
            .Font = StandardFonts.Helvetica,
            .FontSize = 11
        }
        g.DrawString("Generated 2026-05-26 — fluent code-first layout.", body, New PointF(72, 110))

        doc.Save("statement.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>"
        Using pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("invoice.pdf")
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

DsPdf is the right pick for developers who want primitive-level control over text layout, font handling, and PDF object structure; it has a serious text-layout engine and the API style is the cleanest of any code-first PDF library in .NET. IronPDF is the right pick when the PDF originates from web-app data; the developer writes HTML/CSS once and gets a faithful PDF that matches what the user sees in the browser.

Excel Processing

Both suites cover Excel creation, formula recalculation, and PDF export. DsExcel is widely benchmarked as one of the fastest XLSX engines on .NET, with 450+ built-in functions.

// DsExcel is known for fast formula recalculation with 450+ built-in functions.
using GrapeCity.Documents.Excel;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        IWorksheet sheet = book.Worksheets[0];

        sheet.Range["A1"].Value = "Region";
        sheet.Range["B1"].Value = "Revenue";
        sheet.Range["A2"].Value = "EMEA";
        sheet.Range["B2"].Value = 120000;
        sheet.Range["B4"].Formula = "=SUM(B2:B3)";

        book.Calculate();

        book.Save("revenue.xlsx");
        book.Save("revenue.pdf");
    }
}
// DsExcel is known for fast formula recalculation with 450+ built-in functions.
using GrapeCity.Documents.Excel;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        IWorksheet sheet = book.Worksheets[0];

        sheet.Range["A1"].Value = "Region";
        sheet.Range["B1"].Value = "Revenue";
        sheet.Range["A2"].Value = "EMEA";
        sheet.Range["B2"].Value = 120000;
        sheet.Range["B4"].Formula = "=SUM(B2:B3)";

        book.Calculate();

        book.Save("revenue.xlsx");
        book.Save("revenue.pdf");
    }
}
Imports GrapeCity.Documents.Excel

Class Program
    Shared Sub Main()
        Dim book As New Workbook()
        Dim sheet As IWorksheet = book.Worksheets(0)

        sheet.Range("A1").Value = "Region"
        sheet.Range("B1").Value = "Revenue"
        sheet.Range("A2").Value = "EMEA"
        sheet.Range("B2").Value = 120000
        sheet.Range("B4").Formula = "=SUM(B2:B3)"

        book.Calculate()

        book.Save("revenue.xlsx")
        book.Save("revenue.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
Imports IronXL

Module Program
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

        sheet("A1").Value = "Product"
        sheet("B1").Value = "Units"
        sheet("A2").Value = "Widget A"
        sheet("B2").Value = 1024
        sheet("A3").Value = "Widget B"
        sheet("B3").Value = 768
        sheet("B4").Formula = "=SUM(B2:B3)"

        workbook.EvaluateAll()
        workbook.SaveAs("sales.xlsx")
    End Sub
End Module
$vbLabelText   $csharpLabel

DsExcel's calculation depth (450+ built-in functions, fast recalculation on very large workbooks) is the strongest single technical card in the Document Solutions deck. IronXL covers the read/write/recalc scope that most backend XLSX work needs, with an indexer-style cell API (sheet["B4"].Formula = …, workbook.EvaluateAll()) that reads naturally in modern .NET. Workloads with heavy formula recalculation against multi-million-cell workbooks favour DsExcel; everyday data-out-of-database-into-XLSX flows reach the goal faster with IronXL.

Word Processing

Both suites cover DOCX creation. DsWord uses the same fluent code-first style as DsPdf, mapping a body/sections/paragraphs/runs model directly to OOXML.

// DsWord generates and edits DOCX with a similar fluent code-first style.
using GrapeCity.Documents.Word;

class Program
{
    static void Main()
    {
        GcWordDocument doc = new GcWordDocument();
        Section section = doc.Body.Sections.Add();

        Paragraph title = section.GetRange().Paragraphs.Add("Quarterly Report");
        title.Style = doc.Styles[BuiltInStyleId.Heading1];

        Paragraph body = section.GetRange().Paragraphs.Add(
            "Generated from a .NET service with no Microsoft Word dependency.");
        body.Style = doc.Styles[BuiltInStyleId.Normal];

        doc.Save("report.docx");
        doc.Save("report.pdf");
    }
}
// DsWord generates and edits DOCX with a similar fluent code-first style.
using GrapeCity.Documents.Word;

class Program
{
    static void Main()
    {
        GcWordDocument doc = new GcWordDocument();
        Section section = doc.Body.Sections.Add();

        Paragraph title = section.GetRange().Paragraphs.Add("Quarterly Report");
        title.Style = doc.Styles[BuiltInStyleId.Heading1];

        Paragraph body = section.GetRange().Paragraphs.Add(
            "Generated from a .NET service with no Microsoft Word dependency.");
        body.Style = doc.Styles[BuiltInStyleId.Normal];

        doc.Save("report.docx");
        doc.Save("report.pdf");
    }
}
Imports GrapeCity.Documents.Word

Class Program
    Shared Sub Main()
        Dim doc As New GcWordDocument()
        Dim section As Section = doc.Body.Sections.Add()

        Dim title As Paragraph = section.GetRange().Paragraphs.Add("Quarterly Report")
        title.Style = doc.Styles(BuiltInStyleId.Heading1)

        Dim body As Paragraph = section.GetRange().Paragraphs.Add("Generated from a .NET service with no Microsoft Word dependency.")
        body.Style = doc.Styles(BuiltInStyleId.Normal)

        doc.Save("report.docx")
        doc.Save("report.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
Imports IronWord
Imports IronWord.Models

Class Program
    Shared Sub Main()
        Dim doc As New WordDocument()
        Dim heading As New Paragraph()
        heading.AddChild(New TextRun("Quarterly Report — Q1 2026") With {.FontSize = 18, .Bold = True})
        doc.AddParagraph(heading)

        Dim body As New Paragraph()
        body.AddChild(New TextRun("Revenue grew 14% quarter-over-quarter."))
        doc.AddParagraph(body)

        doc.SaveAs("report.docx")
    End Sub
End Class
$vbLabelText   $csharpLabel

DsWord's fluent style feels consistent with DsPdf and DsExcel; once a developer has learned one Document Solutions API they have effectively learned all four. IronWord uses a paragraph/text-run object graph that is similarly clean and is consistent with the rest of the Iron Suite API style. Both can save directly to PDF; DsWord routes through its own text-layout engine, IronWord routes through HTML.

Image Processing

DsImaging is one of the four .NET-side Document Solutions core libraries and provides cross-platform image processing primitives. Iron Suite does not include a dedicated image-processing library; image needs are typically handled inside IronPDF (rendering pages to image), IronOCR (image preprocessing before OCR), or via a third-party imaging library.

// DsImaging provides cross-platform image processing primitives that integrate with DsPdf and DsWord.
using GrapeCity.Documents.Imaging;

class Program
{
    static void Main()
    {
        using GcBitmap source = new GcBitmap();
        source.Load("source.jpg");

        using GcBitmap thumbnail = source.Resize(240, 160, InterpolationMode.Cubic);
        thumbnail.SaveAsJpeg("thumbnail.jpg");
    }
}
// DsImaging provides cross-platform image processing primitives that integrate with DsPdf and DsWord.
using GrapeCity.Documents.Imaging;

class Program
{
    static void Main()
    {
        using GcBitmap source = new GcBitmap();
        source.Load("source.jpg");

        using GcBitmap thumbnail = source.Resize(240, 160, InterpolationMode.Cubic);
        thumbnail.SaveAsJpeg("thumbnail.jpg");
    }
}
Imports GrapeCity.Documents.Imaging

Class Program
    Shared Sub Main()
        Using source As New GcBitmap()
            source.Load("source.jpg")

            Using thumbnail As GcBitmap = source.Resize(240, 160, InterpolationMode.Cubic)
                thumbnail.SaveAsJpeg("thumbnail.jpg")
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Iron Suite does not provide a direct equivalent for this capability. Iron Suite's positioning intentionally narrows to the ~10 highest-volume document categories, and dedicated raster image manipulation sits outside that scope; Iron Suite users typically combine IronOCR preprocessing helpers (deskew, denoise, contrast) for image-cleanup workflows, or pull in an image library like ImageSharp alongside Iron Suite when raster transforms are required.

Why Choose Iron Suite for Code-First .NET Document Automation

For .NET teams whose workload extends past PDF/Excel/Word/Imaging into recognition (OCR, barcode, QR) and adjacent backend categories (web scraping, ZIP archiving, programmatic printing), Iron Suite is the broader-bundle answer at a lower entry price. Structural edges that matter for everyday code-first .NET document work:

  • Perpetual ownership vs annual subscription: you own the version you buy
  • Lower entry tier: Iron Suite Lite starts at $2,998; the MESCIUS .NET Bundle starts at {{mescius_document_solutions.bundle_developer}}
  • Broader 10-product bundle including OCR, barcode, QR, web scraping, ZIP, and print, none of which are in the MESCIUS .NET catalogue
  • HTML-first PDF generation with browser fidelity for web-data-to-PDF workloads
  • Royalty-free deployment for licensed seats out of the box; SaaS/OEM via a single Redistribution Add-On
  • One license-key registration model across all 10 products

How is Iron Suite Different from Document Solutions for .NET

  • Broader bundle for less money. Iron Suite covers 10 product categories at an entry price below the MESCIUS .NET Bundle's {{mescius_document_solutions.bundle_developer}} tier, and adds OCR, barcode, QR, scraping, ZIP, and print that have no MESCIUS equivalent.
  • Perpetual vs subscription. Iron Suite is perpetual per-developer; Document Solutions is annual subscription with reduced renewal rates after year 1.
  • Recognition stack out of the box (IronOCR, IronBarcode, IronQR). MESCIUS has no OCR or barcode product in the .NET catalogue.
  • PowerPoint support. IronPPT covers PPTX inside the bundle; MESCIUS has no DsPowerPoint product.
  • HTML-first PDF flow vs DsPdf's fluent primitive-level layout, different style for different workloads (web data vs precise programmatic layout).
  • Brand transition surface area. Document Solutions packages now ship as DS.Documents.* on NuGet but in-code namespaces remain GrapeCity.Documents.*; onboarding documentation and tooling configurations may need updating across both names.

Conclusion

Document Solutions for .NET is the right pick for teams that need a fluent code-first PDF layout API, the deep Excel calculation engine in DsExcel, and a consistent fluent API across PDF/Excel/Word/Imaging, particularly reporting-heavy or financial-services workflows where DsExcel's calculation depth pays off. Iron Suite is the right pick for teams whose document workload extends into recognition, web scraping, and adjacent backend categories, and who prefer a perpetual license at a lower entry price with a broader 10-product bundle. Explore Iron Suite for .NET, including the $2,998 entry tier.

Please noteDocument Solutions for .NET is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by Document Solutions for .NET. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.