int main()
{
/*int n, t;
cin >> n;
vector <int> Array(n);
for (int i = 0; i < n; i++)
{
cin >> Array[i];
}
FenwickTree* tree = new FenwickTree(Array);
int m, a, b, c;
cin >> m;
for (int i = 0; i < m; i++)
{
cin >> a >> b >> c;
if (a == 1)
cout << tree->GetSum(b, c) << endl;
else
tree->Modify(b, c);
}*/
int n, val, answer = 0;
cin >> n;
FenwickTree* tree = new FenwickTree(n + 1);
for (int i = 0; i < n; i++)
{
cin >> val;
answer += tree->GetSum(val + 1, n);
tree->Modify(val, 1);
}
cout << answer;
return 0;
}
int main(int argc, char *argv[])
{
int A[MAXN + 16];
vector<int> AA;
for (int i = 1; i <= MAXN; i++)
{
A[i] = i;
AA.push_back(i);
}
FenwickTree ft;
ft.prepare(AA);
for (int i = 1; i <= MAXN; i++)
add(i, A[i]);
for (int cases = 1; cases <= 100; cases++) {
int L = rand() % MAXN + 1, R = rand() % MAXN + 1;
if (L > R) swap(L, R);
cout << "S[" << setw(4) << right << L << ", ";
cout << setw(4) << right << R << "] => ";
cout << get(R) - get(L - 1) << " = ";
cout << ft.sum(L - 1, R - 1);
cout << " = " << (R + L) * (R - L + 1) / 2 << '\n';
}
return 0;
}
//-----------------------------------------------------------------------------
int binarySearchForFreePlace(
const FenwickTree& array_of_sums,
int left_border,
int right_border) {
// Left border inclusive, Right border not inclusive
if (right_border == 0 || array_of_sums.sum(left_border, right_border - 1) ==
right_border - left_border) {
return -2; // Later -2 + 1 -> -1
}
while (right_border - left_border > 1) {
int middle = left_border + (right_border - left_border) / 2;
if (array_of_sums.sum(middle, right_border - 1) ==
right_border - middle) {
right_border = middle;
continue;
}
if (array_of_sums.sum(left_border, middle - 1) ==
middle - left_border) {
left_border = middle;
continue;
}
right_border = middle;
}
return left_border;
}
rep(v, n)
{
int d = v + 1 - s, u = 0;
if(d > 0)
{
int i = cnt.find(d);
u = tot.sum(i) + (d - cnt.sum(i)) * (i + 1);
}
ans = min(ans, t + u);
for(auto x : ord[v]) s--, t -= x, cnt.add(x, 1), tot.add(x, x);
}
void divide(int L, int R, int p) {
if (R-L == 1) {
ftree.add(1, n-index[L]-p);
} else {
int i = L;
while(i < R) {
while( index[i]+p >= n ) i++;
int j = i + 1;
while(j < R && index[j]+p < n && s[index[i]+p] == s[index[j]+p]) j++;
ftree.add(j-i,j-i);
// cout << i << ' ' << j << " pos: " << p+1 << endl;
divide(i, j, p+1);
i = j;
}
}
}
int main (){
ios::sync_with_stdio(false);
cin>>n;
int total=1;
FenwickTree tree (n+5);
long long count = 0;
while(n--) {
int t;
cin>>t;
if (t == 1) {
int x,a;
cin>>a>>x;
tree.add(0,x);
tree.add(a,-x);
count += a*x;
}
else if (t == 2) {
int main ()
{
size_t n;
cin >> n;
FenwickTree tr (n);
int res = 0;
for (size_t i = 0; i < n; ++i)
{
int cur;
cin >> cur;
tr.modify (cur - 1, 1);
res += tr.sum (cur, n - 1);
}
cout << res;
return 0;
}
//-----------------------------------------------------------------------------
int calculateTakenPlace(FenwickTree& array_of_sums, int arrive_at_place) {
if (array_of_sums.at(arrive_at_place) == 0) {
array_of_sums.add(arrive_at_place, 1);
return arrive_at_place;
}
int occupied_place = -2;
if (arrive_at_place + 1 < array_of_sums.size()) {
occupied_place = binarySearchForFreePlace(
array_of_sums,
arrive_at_place + 1,
array_of_sums.size());
}
if (occupied_place == -2) {
occupied_place = binarySearchForFreePlace(
array_of_sums,
0,
arrive_at_place);
}
array_of_sums.add(occupied_place, 1);
return occupied_place;
}
ll query(int i) {
return ftree.query(n) - ftree.query(i-1);
}
i64 sum(int pos){
return delta.sum(pos) * pos - delta_i.sum(pos);
}
void rangeAfterAdd(int pos, i64 v){
delta.add(pos, v);
delta_i.add(pos, v * (pos - 1));
}
