This file is indexed.

/usr/include/bobcat/primefactors is in libbobcat-dev 4.01.03-2ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#ifndef INCLUDED_BOBCAT_PRIMEFACTORS_
#define INCLUDED_BOBCAT_PRIMEFACTORS_

#include <iostream>
#include <vector>
#include <fstream>
#include <memory>

#include <bobcat/bigint>

namespace FBB
{

struct PrimeFactors
{
    struct PrimePower
    {
        BigInt prime;
        size_t power;
    };

    typedef std::vector<PrimePower> Factors;

    private:
        typedef std::vector<BigInt> BigIntVector;
        typedef BigIntVector::const_iterator ConstIterator;
    
        class iterator
        {
            protected:
                enum InputMode
                {
                    PRIMES,
                    SENTINEL
                };
                int d_mode;

                BigIntVector *d_primes;
                ConstIterator d_iterator;
                BigInt d_lastPrime;
                BigIntVector d_sentinel;
                    
            public:
                virtual ~iterator();
                iterator();
                iterator(BigIntVector &primes);     // 2

                iterator &operator++();                         //    opinc.f
                void setSentinel(BigInt const &sentinel);               // .f
                BigInt const &operator*() const;                //   opstar.f
                void nextPrime();                                       // .f
                BigInt const &lastPrime() const;                        // .f
                bool atSentinel() const;                                // .f

            protected:
                void checkInitialPrimes(BigIntVector const &primes) const;
                bool isComposite(BigInt const &candidate);
    
            private:
                virtual iterator &operatorPreInc();
                virtual void next();
        };

        class iteratorStream;

        BigInt d_value;
        BigInt d_last;

        std::shared_ptr<iterator> d_iterator;
    
        Factors d_factors;

    public:
        PrimeFactors(BigIntVector &primes);
        PrimeFactors(std::string const &name = "", size_t blockSize = 1000);
        PrimeFactors(PrimeFactors const &other) = delete;

        Factors const &factorize(BigInt const &value);

    private:
        void reduce(BigInt const &prime);
        void availablePrimes();
        void addPrimes();
};

} // FBB        
#endif