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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// PR tree-optimize/42337
// { dg-do compile }
// { dg-options "-O2" }
template<class _T1, class _T2> struct pair {
_T2 second;
};
template<typename _Tp>
inline const _Tp& max(const _Tp& __a, const _Tp& __b) { }
template<typename _ForwardIterator, typename _Tp, typename _Compare> _ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { }
template<class _CharT> struct char_traits {};
template<typename _Iterator, typename _Container> class __normal_iterator {
public: typedef _Iterator iterator_type;
__normal_iterator& operator++() {
}
};
template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) { }
template<typename _Tp> class new_allocator {
public:
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
};
template<typename _Tp>
class allocator: public new_allocator<_Tp> {
public:
template<typename _Tp1> struct rebind {
typedef allocator<_Tp1> other;
};
};
template<typename _Arg, typename _Result> struct unary_function { };
template<typename _Arg1, typename _Arg2, typename _Result> struct binary_function { };
template<typename _Tp> struct less : public binary_function<_Tp, _Tp, bool> { };
template<typename _Pair> struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { };
template<typename _Tp> struct _Rb_tree_iterator {
typedef _Tp* pointer;
pointer operator->() const {
}
};
template<typename _Key, typename _Val, typename _KeyOfValue, typename _Compare, typename _Alloc = allocator<_Val> >
class _Rb_tree {
typedef _Val value_type;
public: typedef _Rb_tree_iterator<value_type> iterator;
};
template <typename _Key, typename _Tp, typename _Compare = less<_Key>, typename _Alloc = allocator<pair<const _Key, _Tp> > >
class map {
public: typedef _Key key_type;
typedef pair<const _Key, _Tp> value_type;
typedef _Compare key_compare;
private: typedef typename _Alloc::template rebind<value_type>::other _Pair_alloc_type;
typedef _Rb_tree<key_type, value_type, _Select1st<value_type>, key_compare, _Pair_alloc_type> _Rep_type;
public: typedef typename _Pair_alloc_type::pointer pointer;
typedef typename _Rep_type::iterator iterator;
iterator find(const key_type& __x) { }
};
template<typename _Tp, typename _Alloc> struct _Vector_base {
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
};
template<typename _Tp, typename _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc> {
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
public:
typedef typename _Tp_alloc_type::pointer pointer;
typedef typename _Tp_alloc_type::const_pointer const_pointer;
typedef __normal_iterator<pointer, vector> iterator;
typedef __normal_iterator<const_pointer, vector> const_iterator;
iterator begin() { }
const_iterator begin() const { }
const_iterator end() const { }
unsigned long size() const { }
};
class SSC {
public:
SSC () {}
SSC (const int& cs);
};
extern int flag;
struct TP {
const int cl_;
const vector<int> &its_;
int max_s_;
};
double foo(TP *p);
map<int, int> cs_;
template <typename T> class vector32 {
public:
typedef T& reference;
typedef T* iterator;
typedef const T* const_iterator;
iterator begin() { return data_; }
iterator end() { return data_ + size_; }
long unsigned int size() const { return size_; }
T* data_;
unsigned size_;
};
struct SF : public pair<unsigned long long, double> { };
template<typename KEY, typename VALUE> class SFVT {
private: typedef vector32<SF> Container;
typedef typename Container::const_iterator CI;
mutable Container v_;
mutable bool sorted_;
struct Cmp : public binary_function<SF, SF, bool> {
};
__attribute__((always_inline)) VALUE IS(const SFVT &sfv) const {
if (sfv.v_.size() < v_.size()) {
return sfv.IS(*this);
}
else {
VALUE sum = 0.0;
CI beg = sfv.v_.begin();
CI end = sfv.v_.end();
for (CI i = v_.begin();
i != v_.end();
++i) { beg = lower_bound(beg, end, *i, Cmp()); if (beg == end) { return sum; } }
}
}
public: explicit SFVT(const int capacity = 0) : sorted_(true) { }
long unsigned int size() const { }
__attribute__((always_inline)) VALUE DP(const SFVT &sfv) const {
return IS(sfv);
}
};
class SFV : public SFVT<unsigned long long, double> { };
class Edge;
extern int flag2;
double foo(TP *p) {
int nbests_requested = max(p->max_s_, flag);
map<int, int>::iterator it = cs_.find(p->cl_);
int* c = &it->second;
for (vector<int>::const_iterator iter = p->its_.begin();
iter != p->its_.end();
++iter) {
}
vector<int*> fb;
vector<double> w;
int *hg = 0;
if (flag2 == 10) {
hg = &flag2;
}
int nr = 0;
for (vector<int*>::iterator iter = fb.begin();
(iter != fb.end() && nr < nbests_requested);
++iter) {
}
if (hg) {
SFV s_weights;
for (int i = 0;
i < w.size();
++i) {
}
SFV uw;
for (int i = 0, j = 0;
i < uw.size() && j < s_weights.size();
) {
}
const double tc = uw.DP(s_weights);
}
}
|
