COMPARAçãO

FastReport vs IronPDF: Guia de Comparação Técnica

Atualizado:

Quando os desenvolvedores .NET avaliam soluções de geração de PDF, o Relatório Rápido destaca-se como um poderoso mecanismo de relatórios com recursos de design visual. Não entanto, seu foco em relatórios, a curva de aprendizado acentuada com conceitos baseados em bandas e a dependência de designers visuais levam muitas equipes a buscar alternativas para geração de PDF de propósito geral.IronPDFoferece uma abordagem moderna usando tecnologias webHTML/CSSque a maioria dos desenvolvedores já conhece, apresentando uma API mais simples e capacidades mais amplas de manipulação de PDF.

Esta comparação revisa ambas as bibliotecas em dimensões tecnicamente relevantes para ajudar desenvolvedores profissionais e arquitetos a tomar decisões informadas para suas necessidades de PDF .NET.

Compreendendo o FastReport

FastReport.NET é uma solução de relatórios comercial construída para o ecossistema .NET, projetada para criar relatórios complexos e altamente interativos a partir de várias fontes de dados com saída em vários formatos, incluindo PDF. A biblioteca é notavelmente utilizada por desenvolvedores que precisam de um mecanismo de relatórios confiável apoiado por um designer de relatórios visual, otimizado para a construção de relatórios detalhados com controle sofisticado de layout.

FastReport usa uma arquitetura baseada em bandas com conceitos como DataBand, PageHeaderBand e PageFooterBand que exigem a compreensão de modelos específicos de relatório. A biblioteca trabalha com arquivos de modelo .frx criados através do designer visual ou manipulados programaticamente. A geração de PDF flui através da classe Report com métodos Prepare() e Export() usando objetos PDFSimpleExport ou PDFExport.

Embora Relatório Rápido forneça ferramentas completas para geração de relatórios, ele se concentra principalmente na geração de relatórios e pode não ser a melhor opção para cenários que exigem geração e manipulação de PDF versátil ou de propósito geral. A dependência de seu designer visual para criar layouts complexos torna-o menos flexível para geração puramente programática de PDF.

Entendendo o IronPDF

IronPDF é uma biblioteca de PDF de propósito geral que permite aos desenvolvedores usar conteúdo HTML existente para gerar PDFs sem ferramentas especializadas. A biblioteca usa um moderno mecanismo de renderização Chromium, permitindo a conversão de conteúdo HTML e web em PDFs de alta qualidade com suporte total a CSS3, incluindo layouts Flexbox e Grid.

IronPDF usa ChromePdfRenderer como sua classe principal de renderização, com renderização de entrada direta de string HTML ou arquivo para objetos PdfDocument. A biblioteca suporta manipulação completa de PDF, incluindo fusão, divisão, configurações de segurança e manipulação de formulários — capacidades que vão além da exportação focada em relatórios.

Comparação de Abordagem de Arquitetura e Design

A diferença fundamental entre essas bibliotecas de PDF .NET está em seu modelo de design e casos de uso pretendidos.

Aspecto Relatório Rápido IronPDF
Abordagem de projeto Designer visual + arquivos .frx HTML/CSS(tecnologias web)
Curva de Aprendizagem Íngreme (conceitos baseados em bandas) Gentil (conhecimento de HTML/CSS)
Vinculação de dados RegistrarDados(), BandaDeDados Interpolação de strings, Razor, criação de modelos
Suporte a CSS Limitado CSS3 completo com Flexbox/Grid
Modelo de pacote Vários pacotes Pacote único (todos os recursos)
Motor de renderização Personalizado Última versão do Chromium
Manipulação de PDF Focado na exportação Completo (fusão, divisão, segurança, formulários)
.NET moderno .NET Standard 2.0 .NET 6/7/8/9+ nativo

A especialização do Relatório Rápido em tarefas de relatórios significa que ele não é tão versátil para usuários que procuram uma biblioteca de manipulação de PDF de propósito geral. O designer visual é tanto uma força quanto uma possível limitação para aqueles que preferem codificar em vez de desenhar.

Comparação de código: operações comuns em PDF

Conversão de HTML para PDF

Converter conteúdo HTML em PDF demonstra as diferenças fundamentais de complexidade de API.

FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            // Create HTML object
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 500;
            htmlObject.Height = 300;
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>";

            // Prepare report
            report.Prepare();

            // Export to PDF
            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            // Create HTML object
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 500;
            htmlObject.Height = 300;
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>";

            // Prepare report
            report.Prepare();

            // Export to PDF
            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("output.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO

Class Program
    Shared Sub Main()
        Using report As New Report()
            ' Create HTML object
            Dim htmlObject As New FastReport.HTMLObject()
            htmlObject.Width = 500
            htmlObject.Height = 300
            htmlObject.Text = "<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>"

            ' Prepare report
            report.Prepare()

            ' Export to PDF
            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("output.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1><p>This is a test PDF</p></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

FastReport requer a criação de um HTMLObject com dimensões de largura e altura explícitas, preparando o relatório, criando uma instância PDFSimpleExport e manipulando manualmente o FileStream para saída.IronPDFsimplifica isso para três linhas: criar renderizador, renderizar HTML, salvar.

Para opções avançadas de renderização HTML, explore o guia de conversão de HTML para PDF .

Conversão de URL para PDF

Capturar páginas da web como documentos PDF revela diferenças significativas no fluxo de trabalho.

FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // Download HTML content from URL
        string htmlContent;
        using (WebClient client = new WebClient())
        {
            htmlContent = client.DownloadString("https://example.com");
        }

        using (Report report = new Report())
        {
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 800;
            htmlObject.Height = 600;
            htmlObject.Text = htmlContent;

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("webpage.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;
using System.Net;

class Program
{
    static void Main()
    {
        // Download HTML content from URL
        string htmlContent;
        using (WebClient client = new WebClient())
        {
            htmlContent = client.DownloadString("https://example.com");
        }

        using (Report report = new Report())
        {
            FastReport.HTMLObject htmlObject = new FastReport.HTMLObject();
            htmlObject.Width = 800;
            htmlObject.Height = 600;
            htmlObject.Text = htmlContent;

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("webpage.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO
Imports System.Net

Class Program
    Shared Sub Main()
        ' Download HTML content from URL
        Dim htmlContent As String
        Using client As New WebClient()
            htmlContent = client.DownloadString("https://example.com")
        End Using

        Using report As New Report()
            Dim htmlObject As New FastReport.HTMLObject()
            htmlObject.Width = 800
            htmlObject.Height = 600
            htmlObject.Text = htmlContent

            report.Prepare()

            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("webpage.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

FastReport não possui capacidade nativa de URL-para-PDF—os desenvolvedores devem baixar manualmente o conteúdo HTML usando WebClient, depois criar um HTMLObject com o conteúdo baixado e dimensões explícitas.IronPDFfornece funcionalidade RenderUrlAsPdf() direta que lida automaticamente com a busca de URL, execução de JavaScript e renderização.

Saiba mais sobre a renderização de URL na documentação da URL para PDF.

Cabeçalhos e rodapés com números de página

Adicionar cabeçalhos e rodapés demonstra as diferenças arquitetônicas entre relatórios baseados em bandas e renderização baseada em HTML.

FastReport:

// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            report.Load("template.frx");

            // Set report page properties
            FastReport.ReportPage page = report.Pages[0] as FastReport.ReportPage;

            // Add page header
            FastReport.PageHeaderBand header = new FastReport.PageHeaderBand();
            header.Height = 50;
            FastReport.TextObject headerText = new FastReport.TextObject();
            headerText.Text = "Document Header";
            header.Objects.Add(headerText);
            page.Bands.Add(header);

            // Add page footer
            FastReport.PageFooterBand footer = new FastReport.PageFooterBand();
            footer.Height = 50;
            FastReport.TextObject footerText = new FastReport.TextObject();
            footerText.Text = "Page [Page]";
            footer.Objects.Add(footerText);
            page.Bands.Add(footer);

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("report.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
// NuGet: Install-Package FastReport.OpenSource
using FastReport;
using FastReport.Export.PdfSimple;
using System.IO;

class Program
{
    static void Main()
    {
        using (Report report = new Report())
        {
            report.Load("template.frx");

            // Set report page properties
            FastReport.ReportPage page = report.Pages[0] as FastReport.ReportPage;

            // Add page header
            FastReport.PageHeaderBand header = new FastReport.PageHeaderBand();
            header.Height = 50;
            FastReport.TextObject headerText = new FastReport.TextObject();
            headerText.Text = "Document Header";
            header.Objects.Add(headerText);
            page.Bands.Add(header);

            // Add page footer
            FastReport.PageFooterBand footer = new FastReport.PageFooterBand();
            footer.Height = 50;
            FastReport.TextObject footerText = new FastReport.TextObject();
            footerText.Text = "Page [Page]";
            footer.Objects.Add(footerText);
            page.Bands.Add(footer);

            report.Prepare();

            PDFSimpleExport pdfExport = new PDFSimpleExport();
            using (FileStream fs = new FileStream("report.pdf", FileMode.Create))
            {
                report.Export(pdfExport, fs);
            }
        }
    }
}
Imports FastReport
Imports FastReport.Export.PdfSimple
Imports System.IO

Class Program
    Shared Sub Main()
        Using report As New Report()
            report.Load("template.frx")

            ' Set report page properties
            Dim page As FastReport.ReportPage = TryCast(report.Pages(0), FastReport.ReportPage)

            ' Add page header
            Dim header As New FastReport.PageHeaderBand()
            header.Height = 50
            Dim headerText As New FastReport.TextObject()
            headerText.Text = "Document Header"
            header.Objects.Add(headerText)
            page.Bands.Add(header)

            ' Add page footer
            Dim footer As New FastReport.PageFooterBand()
            footer.Height = 50
            Dim footerText As New FastReport.TextObject()
            footerText.Text = "Page [Page]"
            footer.Objects.Add(footerText)
            page.Bands.Add(footer)

            report.Prepare()

            Dim pdfExport As New PDFSimpleExport()
            Using fs As New FileStream("report.pdf", FileMode.Create)
                report.Export(pdfExport, fs)
            End Using
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        };

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>");
        pdf.SaveAs("report.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        // Configure header and footer
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        };

        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        };

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>");
        pdf.SaveAs("report.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        ' Configure header and footer
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:center'>Document Header</div>"
        }

        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
            .HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
        }

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Report Content</h1><p>This is the main content.</p></body></html>")
        pdf.SaveAs("report.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

FastReport requer carregar um arquivo de modelo, acessar o ReportPage, criar objetos PageHeaderBand e PageFooterBand, adicionar elementos TextObject com alturas explícitas e adicionar bandas à página. O marcador de posição do número da página usa a sintaxe [Page].

IronPDF usa objetos HtmlHeaderFooter com propriedades HtmlFragment contendoHTML/CSSpadrão. Os números das páginas usam marcadores de posição {page} e {total-pages}. A abordagem HTML permite controle total de estilo usando CSS.

Referência de Mapeamento de Métodos

Para desenvolvedores avaliando migração de Relatório Rápido ou comparando capacidades, esse mapeamento mostra operações equivalentes:

Mapeamento de Classes Principais

Relatório Rápido IronPDF
Report ChromePdfRenderer
PDFExport ChromePdfRenderer + SecuritySettings
PDFSimpleExport ChromePdfRenderer
ReportPage HTML <body> ou <div>
TextObject HTML <p>, <span>, <div>
TableObject HTML <table>
DataBand Loop em modelo
PageHeaderBand HtmlHeaderFooter
PageFooterBand HtmlHeaderFooter
HTMLObject Renderização direta de HTML
PictureObject HTML <img>

Mapeamento de Métodos

Relatório Rápido IronPDF
report.Load(path) Ler arquivo de modelo HTML
report.RegisterData(data, name) Vinculação direta de dados no HTML
report.Prepare() N / D
report.Export(export, path) pdf.SaveAs(path)
report.Export(export, stream) pdf.Stream ou pdf.BinaryData

Espaços Reservados de Numeração de Páginas

Relatório Rápido IronPDF
[Page] {page}
[TotalPages] {total-pages}

Resumo da comparação de recursos

Recurso Relatório Rápido IronPDF
HTML para PDF Sim (via HTMLObject) Sim (nativo)
URL para PDF Não (download manual) Sim (nativo)
Designer visual Sim Não
Layout baseado em bandas Sim HTML/CSS
Cabeçalhos/rodapés Sim (PageHeaderBand) Sim (HtmlHeaderFooter)
Numeração de páginas Sim ([Page]) Sim ({page})
Integração de fonte de dados Sim (RegisterData) Modelagem HTML
Mesclagem de PDF Limitado Sim
Divisão de PDF Limitado Sim
Segurança de PDF Versão comercial Sim
Preenchimento de formulário Limitado Sim
CSS3 Flexbox/Grid Não Sim

Quando as equipes consideram mudar do Relatório Rápido para o IronPDF

As equipes de desenvolvimento avaliam a transição do Relatório Rápido para oIronPDFpor vários motivos:

Desenvolvimento Baseado em Código: A dependência do Relatório Rápido no designer visual ou no conhecimento profundo de arquivos .frx limita as abordagens de desenvolvimento baseadas em código.IronPDFpermite que desenvolvedores gerem PDFs inteiramente através de código usandoHTML/CSSfamiliar.

Curva de Aprendizado: A arquitetura baseada em bandas do Relatório Rápido (DataBand, PageHeaderBand, PageFooterBand) requer a compreensão de conceitos específicos de relatório. Desenvolvedores com experiência em web acham a abordagemHTML/CSSdoIronPDFmais intuitiva.

CSS e Layouts Modernos: O suporte limitado a CSS do Relatório Rápido significa que a estilização padrão da web não está disponível nativamente — a estilização usa o formato proprietário do FastReport. O motor Chromium doIronPDFfornece suporte total a CSS3, incluindo Flexbox e Grid.

Manipulação Geral de PDF: O Relatório Rápido é focado em exportação, oferecendo capacidades limitadas de manipulação de PDF.IronPDFoferece manuseio completo de PDF, incluindo mesclagem, divisão, segurança e gerenciamento de formulários.

Consolidação de Pacotes: Relatório Rápido requer múltiplos pacotes NuGet (FastReport.OpenSource, FastReport.OpenSource.Export.PdfSimple, etc.) para funcionalidade completa.IronPDFconsolida todas as funcionalidades em um único pacote.

Flexibilidade de Licenciamento: A versão de código aberto do Relatório Rápido tem recursos limitados; a versão comercial é necessária para criptografia de PDF, assinatura digital e incorporação de fontes.IronPDFinclui essas capacidades em sua oferta padrão.

Pontos fortes e considerações

Forças do FastReport

  • Relatórios Abrangentes: Lida com requisitos de relatórios intrincados com dados complexos de várias fontes
  • Ferramentas de Design Visual: Designer intuitivo para criar relatórios sem codificação
  • Flexibilidade de Fonte de Dados: Conecta-se a várias fontes, incluindo bancos de dados, JSON e XML
  • Layouts Complexos: Suporta controle sofisticado de layout para relatórios detalhados

Considerações sobre o FastReport

  • Focado em Relatórios: Especialização limita versatilidade para manipulação geral de PDF
  • Dependência do Designer: Designer visual pode se tornar uma muleta para desenvolvedores de código primeiro
  • Curva de Aprendizado Íngreme: Conceitos baseados em bandas requerem investimento significativo em aprendizagem
  • Suporte CSS Limitado: Estilização padrão da web não suportada nativamente
  • Pacotes Fragmentados: Múltiplos pacotes NuGet necessários para funcionalidade completa
  • Gatilho de Funcionalidade: Recursos avançados requerem licença comercial

Pontos fortes do IronPDF

  • Tecnologias Web: AbordagemHTML/CSSfamiliar para a maioria dos desenvolvedores
  • Renderização Moderna: Último motor Chromium para saída perfeita de pixels
  • Pacote Único: Todas as funcionalidades (mesclagem, divisão, segurança, formulários) em um NuGet
  • Renderização de URL Direta: Suporte nativo para conversão de páginas web para PDF
  • Suporte Completo ao CSS3: Flexbox, Grid e layouts modernos de CSS
  • Propósito Geral: Geração e manipulação de PDF em uma única biblioteca
  • Recursos abrangentes: tutoriais e documentação extensivos

Considerações sobre o IronPDF

  • Sem Designer Visual: Design de layout acontece emHTML/CSS(editores web funcionam bem)
  • Paradigma Diferente: Modelos baseados em bandas precisam de conversão para HTML

Conclusão

FastReport eIronPDFservem a propósitos principais diferentes no ecossistema .NET. Relatório Rápido se destaca como um motor de relatórios especializado com capacidades de design visual, arquitetura baseada em bandas e forte integração de fonte de dados — ideal para aplicativos onde relatórios complexos com design visual são centrais.

IronPDF fornece uma solução de PDF moderna e de propósito geral usando tecnologias web que a maioria dos desenvolvedores já conhece. Para equipes que buscam desenvolvimento orientado a código, suporte moderno a CSS, renderização de URL direta ou manipulação abrangente de PDF além da exportação, oIronPDFoferece uma abordagem mais adequada.

Conforme as organizações planejam para o .NET 10, C# 14 e desenvolvimento de aplicativos até 2026, a escolha depende de requisitos específicos. Equipes construindo aplicativos centrados em relatórios com fluxos de trabalho de design visual podem continuar achando o Relatório Rápido valioso. Para aplicativos que requerem renderização de conteúdo web dinâmico, layouts modernos ou manipulação versátil de PDF, oIronPDFfornece a flexibilidade e simplicidade que o desenvolvimento moderno demanda.

Comece a avaliar oIronPDFcom um teste gratuito e explore a documentação completa para verificar se ele atende às suas necessidades específicas.

ObserveFastReport é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pela Fast Reports. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.