Related Articles
Count quadruplets with sum K from given array
• Last Updated : 04 Dec, 2020

Given an array arr[] of size N and an integer S, the task is to find the count of quadruplets present in the given array having sum S

Examples:

Input: arr[] = {1, 5, 3, 1, 2, 10}, S = 20
Output: 1
Explanation: Only quadruplet satisfying the conditions is arr + arr + arr + arr = 5 + 3 + 2 + 10 = 20.

Input: N = 6, S = 13, arr[] = {4, 5, 3, 1, 2, 4}
Output: 3
Explanation: Three quadruplets with sum 13 are:

1. arr + arr + arr + arr = 4 + 3 + 2 + 4 = 13
2. arr + arr + arr + arr = 4 + 5 + 3 + 1 = 13
3. arr + arr + arr + arr = 5 + 3 + 1 + 4 = 13

Naive Approach: The idea is to generate all possible combinations of length 4 from the given array. For each quadruplet, if the sum equals S, then increment the counter by 1. After checking all the quadruplets, print the counter as the total number of quadruplets having sum S.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to return the number of` `// quadruplets with the given sum` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{` `    ``// Initialize variables` `    ``int` `i, j, k, l;`   `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// All possible first elements` `    ``for` `(i = 0; i < n - 3; i++) {`   `        ``// All possible second elements` `        ``for` `(j = i + 1; j < n - 2; j++) {`   `            ``// All possible third elements` `            ``for` `(k = j + 1; k < n - 1; k++) {`   `                ``// All possible fourth elements` `                ``for` `(l = k + 1; l < n; l++) {`   `                    ``// Increment counter by 1` `                    ``// if quadruplet sum is S` `                    ``if` `(a[i] + a[j]` `                            ``+ a[k] + a[l]` `                        ``== sum)` `                        ``count++;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the final count` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``cout << countSum(arr, N, S);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{` `  `  `// Function to return the number of` `// quadruplets with the given sum` `static` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j, k, l;`   `    ``// Initialize answer` `    ``int` `count = ``0``;`   `    ``// All possible first elements` `    ``for``(i = ``0``; i < n - ``3``; i++) ` `    ``{` `        `  `        ``// All possible second elements` `        ``for``(j = i + ``1``; j < n - ``2``; j++) ` `        ``{` `            `  `            ``// All possible third elements` `            ``for``(k = j + ``1``; k < n - ``1``; k++)` `            ``{` `                `  `                ``// All possible fourth elements` `                ``for``(l = k + ``1``; l < n; l++) ` `                ``{` `                    `  `                    ``// Increment counter by 1` `                    ``// if quadruplet sum is S` `                    ``if` `(a[i] + a[j] + ` `                        ``a[k] + a[l] == sum)` `                        ``count++;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the final count` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    `  `    ``// Given array arr[]` `    ``int` `arr[] = { ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `};`   `    ``// Given sum S` `    ``int` `S = ``13``;`   `    ``int` `N = arr.length;`   `    ``// Function Call` `    ``System.out.print(countSum(arr, N, S));` `}` `}`   `// This code is contributed by bgangwar59`

## Python3

 `# Python3 program for the above approach`   `# Function to return the number of` `# quadruplets with the given sum` `def` `countSum(a, n, ``sum``):` `    `  `    ``# Initialize variables` `    ``# i, j, k, l`   `    ``# Initialize answer` `    ``count ``=` `0`   `    ``# All possible first elements` `    ``for` `i ``in` `range``(n ``-` `3``):` `        `  `        ``# All possible second elements` `        ``for` `j ``in` `range``(i ``+` `1``, n ``-` `2``):` `            `  `            ``# All possible third elements` `            ``for` `k ``in` `range``(j ``+` `1``, n ``-` `1``):` `                `  `                ``# All possible fourth elements` `                ``for` `l ``in` `range``(k ``+` `1``, n):` `                    `  `                    ``# Increment counter by 1` `                    ``# if quadruplet sum is S` `                    ``if` `(a[i] ``+` `a[j] ``+` `a[k] ``+` `a[l]``=``=` `sum``):` `                        ``count ``+``=` `1` `                        `  `    ``# Return the final count` `    ``return` `count`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array arr[]` `    ``arr ``=` `[ ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `]`   `    ``# Given sum S` `    ``S ``=` `13`   `    ``N ``=` `len``(arr)` `    `  `    ``# Function Call` `    ``print``(countSum(arr, N, S))` `    `  `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `class` `GFG{` `  `  `// Function to return the number of` `// quadruplets with the given sum` `static` `int` `countSum(``int` `[]a, ``int` `n, ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j, k, l;`   `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// All possible first elements` `    ``for``(i = 0; i < n - 3; i++) ` `    ``{` `        `  `        ``// All possible second elements` `        ``for``(j = i + 1; j < n - 2; j++) ` `        ``{` `            `  `            ``// All possible third elements` `            ``for``(k = j + 1; k < n - 1; k++)` `            ``{` `                `  `                ``// All possible fourth elements` `                ``for``(l = k + 1; l < n; l++) ` `                ``{` `                    `  `                    ``// Increment counter by 1` `                    ``// if quadruplet sum is S` `                    ``if` `(a[i] + a[j] + ` `                        ``a[k] + a[l] == sum)` `                        ``count++;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the final count` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    `  `    ``// Given array arr[]` `    ``int` `[]arr = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = arr.Length;`   `    ``// Function Call` `    ``System.Console.Write(countSum(arr, N, S));` `}` `}`   `// This code is contributed by SURENDRA_GANGWAR`

Output:

`3`

Time Complexity: O(N4)
Auxiliary Space: O(N)

Better Approach: To optimize the above approach, the idea is to use a Map data structure. Follow the steps below to solve the problem:

• Initialize the counter count with 0 to store the number of quadruplets.
• Traverse the given array over the range [0, N – 3)using the variable i. For each element arr[i], traverse the array again over the range [i + 1, N – 2) using the variable j and do the following:
• Find the value of the required sum(say req) as (S – arr[i] – arr[j]).
• Initialize the count_twice with 0 that will store the count of ordered pairs in the above subarray with sum (S – arr[i] – arr[j]).
• After finding the count_twice, update the count by count_twice / 2.
• After the above steps, print the value of count as the result.

Below is the implementation of the above idea:

## C++

 `// C++ program for the above approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function to return the number of` `// quadruplets having given sum` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{`   `    ``// Initialize variables` `    ``int` `i, j, k, l;`   `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// All possible first elements` `    ``for` `(i = 0; i < n - 3; i++) {`   `        ``// All possible second element` `        ``for` `(j = i + 1; j < n - 2; j++) {` `            ``int` `req = sum - a[i] - a[j];`   `            ``// Use map to find the` `            ``// fourth element` `            ``unordered_map<``int``, ``int``> m;`   `            ``// All possible third elements` `            ``for` `(k = j + 1; k < n; k++)` `                ``m[a[k]]++;`   `            ``int` `twice_count = 0;`   `            ``// Calculate number of valid` `            ``// 4th elements` `            ``for` `(k = j + 1; k < n; k++) {`   `                ``// Update the twice_count` `                ``twice_count += m[req - a[k]];`   `                ``if` `(req - a[k] == a[k])` `                    ``twice_count--;` `            ``}`   `            ``// Unordered pairs` `            ``count += twice_count / 2;` `        ``}` `    ``}`   `    ``// Return answer` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``cout << countSum(arr, N, S);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to return the number of` `// quadruplets having given sum` `static` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j, k, l;`   `    ``// Initialize answer` `    ``int` `count = ``0``;`   `    ``// All possible first elements` `    ``for``(i = ``0``; i < n - ``3``; i++)` `    ``{` `        `  `        ``// All possible second element` `        ``for``(j = i + ``1``; j < n - ``2``; j++) ` `        ``{` `            ``int` `req = sum - a[i] - a[j];`   `            ``// Use map to find the` `            ``// fourth element` `            ``HashMap m = ``new` `HashMap<>();`   `            ``// All possible third elements` `            ``for``(k = j + ``1``; k < n; k++)` `                ``if` `(m.containsKey(a[k]))` `                ``{` `                    ``m.put(a[k], m.get(a[k]) + ``1``);` `                ``}` `                ``else` `                ``{` `                    ``m.put(a[k], ``1``);` `                ``}` `                `  `            ``int` `twice_count = ``0``;`   `            ``// Calculate number of valid` `            ``// 4th elements` `            ``for``(k = j + ``1``; k < n; k++) ` `            ``{` `                `  `                ``// Update the twice_count` `                ``if` `(m.containsKey(req - a[k]))` `                    ``twice_count += m.get(req - a[k]);`   `                ``if` `(req - a[k] == a[k])` `                    ``twice_count--;` `            ``}`   `            ``// Unordered pairs` `            ``count += twice_count / ``2``;` `        ``}` `    ``}`   `    ``// Return answer` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given array arr[]` `    ``int` `arr[] = { ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `};`   `    ``// Given sum S` `    ``int` `S = ``13``;`   `    ``int` `N = arr.length;`   `    ``// Function Call` `    ``System.out.print(countSum(arr, N, S));` `}` `}`   `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program for the above approach`   `# Function to return the number of` `# quadruplets having given sum` `def` `countSum(a, n, ``sum``):` `    `  `    ``# Initialize variables` `    ``# Initialize answer` `    ``count ``=` `0`   `    ``# All possible first elements` `    ``for` `i ``in` `range``(n ``-` `3``):` `        `  `        ``# All possible second element` `        ``for` `j ``in` `range``(i ``+` `1``, n ``-` `2``, ``1``):` `            ``req ``=` `sum` `-` `a[i] ``-` `a[j]`   `            ``# Use map to find the` `            ``# fourth element` `            ``m ``=` `{}`   `            ``# All possible third elements` `            ``for` `k ``in` `range``(j ``+` `1``, n, ``1``):` `                ``m[a[k]] ``=` `m.get(a[k], ``0``) ``+` `1`   `            ``twice_count ``=` `0`   `            ``# Calculate number of valid` `            ``# 4th elements` `            ``for` `k ``in` `range``(j ``+` `1``, n, ``1``):` `                `  `                ``# Update the twice_count` `                ``twice_count ``+``=` `m.get(req ``-` `a[k], ``0``)`   `                ``if` `(req ``-` `a[k] ``=``=` `a[k]):` `                    ``twice_count ``-``=` `1`   `            ``# Unordered pairs` `            ``count ``+``=` `twice_count ``/``/` `2`   `    ``# Return answer` `    ``return` `count`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given array arr[]` `    ``arr ``=`  `[ ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `]`   `    ``# Given sum S` `    ``S ``=` `13`   `    ``N ``=`  `len``(arr)`   `    ``# Function Call` `    ``print``(countSum(arr, N, S))`   `# This code is contributed by ipg2016107`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to return the number of` `// quadruplets having given sum` `static` `int` `countSum(``int` `[]a, ``int` `n, ` `                    ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j, k; ` `    ``//int l;` `    `  `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// All possible first elements` `    ``for``(i = 0; i < n - 3; i++)` `    ``{` `        `  `        ``// All possible second element` `        ``for``(j = i + 1; j < n - 2; j++) ` `        ``{` `            ``int` `req = sum - a[i] - a[j];`   `            ``// Use map to find the` `            ``// fourth element` `            ``Dictionary<``int``,` `                       ``int``> m = ``new` `Dictionary<``int``,` `                                               ``int``>();`   `            ``// All possible third elements` `            ``for``(k = j + 1; k < n; k++)` `                ``if` `(m.ContainsKey(a[k]))` `                ``{` `                    ``m[a[k]]++;` `                ``}` `                ``else` `                ``{` `                    ``m.Add(a[k], 1);` `                ``}` `                `  `            ``int` `twice_count = 0;`   `            ``// Calculate number of valid` `            ``// 4th elements` `            ``for``(k = j + 1; k < n; k++) ` `            ``{` `                `  `                ``// Update the twice_count` `                ``if` `(m.ContainsKey(req - a[k]))` `                    ``twice_count += m[req - a[k]];`   `                ``if` `(req - a[k] == a[k])` `                    ``twice_count--;` `            ``}`   `            ``// Unordered pairs` `            ``count += twice_count / 2;` `        ``}` `    ``}`   `    ``// Return answer` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Given array []arr` `    ``int` `[]arr = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = arr.Length;`   `    ``// Function Call` `    ``Console.Write(countSum(arr, N, S));` `}` `}`   `// This code is contributed by Princi Singh`

Output:

`3`

Time complexity: O(N3) where N is the size of the given array,
Auxiliary Space: O(N)

Efficient Approach: The idea is similar to the above approach using a map. In this approach, fix the 3rd element, then find and store the frequency of sums of all possible first two elements of any quadruplet of the given array. Follow the below steps to solve the problem:

1. Initialize the counter count to store the total quadruplets with the given sum S and a map to store all possible sums for the first two elements of each possible quadruplet.
2. Traverse the given array over the range [0, N – 1] using the variable i where arr[i] is the fixed 3rd element.
3. Then for each element arr[i] in the above step, traverse the given array over the range [i + 1, N – 1] using the variable j and increment the counter count by map[arr[i] + arr[j]].
4. After traversing from the above loop, for each element arr[i], traverse the array arr[] from j = 0 to i – 1 and increment the frequency of any sum arr[i] + arr[j] of the first two elements of any possible quadruplet by 1 i.e., increment map[arr[i] + arr[j]] by 1.
5. Repeat the above steps for each element arr[i] and then print the counter count as the total number of quadruplets with the given sum S.

Below is the implementation of the above idea:

## C++

 `// C++ program for the above approach`   `#include ` `#include ` `using` `namespace` `std;`   `// Function to return the number of` `// quadruplets having the given sum` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{`   `    ``// Initialize variables` `    ``int` `i, j, k;`   `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// Store the frequency of sum` `    ``// of first two elements` `    ``unordered_map<``int``, ``int``> m;`   `    ``// Traverse from 0 to N-1, where` `    ``// arr[i] is the 3rd element` `    ``for` `(i = 0; i < n - 1; i++) {`   `        ``// All possible 4th elements` `        ``for` `(j = i + 1; j < n; j++) {`   `            ``// Sum of last two element` `            ``int` `temp = a[i] + a[j];`   `            ``// Frequency of sum of first` `            ``// two elements` `            ``if` `(temp < sum)` `                ``count += m[sum - temp];` `        ``}` `        ``for` `(j = 0; j < i; j++) {`   `            ``// Store frequency of all possible` `            ``// sums of first two elements` `            ``int` `temp = a[i] + a[j];`   `            ``if` `(temp < sum)` `                ``m[temp]++;` `        ``}` `    ``}`   `    ``// Return the answer` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given array arr[]` `    ``int` `arr[] = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);`   `    ``// Function Call` `    ``cout << countSum(arr, N, S);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to return the number of` `// quadruplets having the given sum` `static` `int` `countSum(``int` `a[], ``int` `n, ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j, k;`   `    ``// Initialize answer` `    ``int` `count = ``0``;`   `    ``// Store the frequency of sum` `    ``// of first two elements` `    ``HashMap m = ``new` `HashMap<>();`   `    ``// Traverse from 0 to N-1, where` `    ``// arr[i] is the 3rd element` `    ``for``(i = ``0``; i < n - ``1``; i++)` `    ``{` `        `  `        ``// All possible 4th elements` `        ``for``(j = i + ``1``; j < n; j++) ` `        ``{` `            `  `            ``// Sum of last two element` `            ``int` `temp = a[i] + a[j];`   `            ``// Frequency of sum of first` `            ``// two elements` `            ``if` `(temp < sum && m.containsKey(sum - temp))` `                ``count += m.get(sum - temp);` `        ``}` `        ``for``(j = ``0``; j < i; j++) ` `        ``{` `            `  `            ``// Store frequency of all possible` `            ``// sums of first two elements` `            ``int` `temp = a[i] + a[j];`   `            ``if` `(temp < sum)` `                ``if` `(m.containsKey(temp))` `                    ``m.put(temp, m.get(temp) + ``1``);` `                ``else` `                    ``m.put(temp, ``1``);` `        ``}` `    ``}` `    `  `    ``// Return the answer` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given array arr[]` `    ``int` `arr[] = { ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `};`   `    ``// Given sum S` `    ``int` `S = ``13``;`   `    ``int` `N = arr.length;`   `    ``// Function Call` `    ``System.out.print(countSum(arr, N, S));` `}` `}`   `// This code is contributed by Princi Singh`

## Python3

 `# Python3 program for the above approach` `from` `collections ``import` `defaultdict`   `# Function to return the number of` `# quadruplets having the given sum` `def` `countSum(a, n, ``sum``):` `    `  `    ``# Initialize answer` `    ``count ``=` `0`   `    ``# Store the frequency of sum` `    ``# of first two elements` `    ``m ``=` `defaultdict(``int``)`   `    ``# Traverse from 0 to N-1, where` `    ``# arr[i] is the 3rd element` `    ``for` `i ``in` `range``(n ``-` `1``):`   `        ``# All possible 4th elements` `        ``for` `j ``in` `range``(i ``+` `1``, n):`   `            ``# Sum of last two element` `            ``temp ``=` `a[i] ``+` `a[j]`   `            ``# Frequency of sum of first` `            ``# two elements` `            ``if` `(temp < ``sum``):` `                ``count ``+``=` `m[``sum` `-` `temp]`   `        ``for` `j ``in` `range``(i):`   `            ``# Store frequency of all possible` `            ``# sums of first two elements` `            ``temp ``=` `a[i] ``+` `a[j]`   `            ``if` `(temp < ``sum``):` `                ``m[temp] ``+``=` `1`   `    ``# Return the answer` `    ``return` `count`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Given array arr[]` `    ``arr ``=` `[ ``4``, ``5``, ``3``, ``1``, ``2``, ``4` `]`   `    ``# Given sum S` `    ``S ``=` `13`   `    ``N ``=` `len``(arr)`   `    ``# Function Call` `    ``print``(countSum(arr, N, S))`   `# This code is contributed by chitranayal`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to return the number of` `// quadruplets having the given sum` `static` `int` `countSum(``int` `[]a, ``int` `n, ``int` `sum)` `{` `    `  `    ``// Initialize variables` `    ``int` `i, j;`   `    ``// Initialize answer` `    ``int` `count = 0;`   `    ``// Store the frequency of sum` `    ``// of first two elements` `    ``Dictionary<``int``, ` `               ``int``> m = ``new` `Dictionary<``int``,` `                                       ``int``>();`   `    ``// Traverse from 0 to N-1, where` `    ``// arr[i] is the 3rd element` `    ``for``(i = 0; i < n - 1; i++)` `    ``{` `        `  `        ``// All possible 4th elements` `        ``for``(j = i + 1; j < n; j++) ` `        ``{` `            `  `            ``// Sum of last two element` `            ``int` `temp = a[i] + a[j];` `            `  `            ``// Frequency of sum of first` `            ``// two elements` `            ``if` `(temp < sum && m.ContainsKey(sum - temp))` `                ``count += m[sum - temp];` `        ``}` `        `  `        ``for``(j = 0; j < i; j++) ` `        ``{` `            `  `            ``// Store frequency of all possible` `            ``// sums of first two elements` `            ``int` `temp = a[i] + a[j];`   `            ``if` `(temp < sum)` `                ``if` `(m.ContainsKey(temp))` `                    ``m[temp]++;` `                ``else` `                    ``m.Add(temp, 1);` `        ``}` `    ``}` `    `  `    ``// Return the answer` `    ``return` `count;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Given array []arr` `    ``int` `[]arr = { 4, 5, 3, 1, 2, 4 };`   `    ``// Given sum S` `    ``int` `S = 13;`   `    ``int` `N = arr.Length;` `    `  `    ``// Function Call` `    ``Console.Write(countSum(arr, N, S));` `}` `}`   `// This code is contributed by shikhasingrajput`

Output:

`3`

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :