#include<iostream>
#include<vector>
using namespace std;


class drink {
public:
	int x;
	int y;
	drink(int _x, int _y) : x(_x), y(_y) {}
};
int main(){
	int test;
	cin >> test;
	int n, m; // drinksN, water
	for (int i = 0; i < test; ++i) {
		cin >> n >> m;
		vector<drink> drinks;
		int x, y;
		for (int j = 0; j < n; ++j) {
			cin >> x >> y;
			drinks.push_back(drink(x, y));
		}
		// main
		int min = INT_MAX;
		for (drink d : drinks) {
			int number = m / d.x;
			int rest = m % d.x;
			if (rest != 0)
				number++;
			int res = number * d.y;
			if (res < min)
				min = res;
		}
		cout << min << endl;
	}
	return 0;
}

#include<iostream>
#include<algorithm>
using namespace std;
double Max;
int scores[11] = { 95,90,85,80,75,70,67,65,62,60,0 };
double gpa[11] = { 4.3,4.0,3.7,3.3,3.0,2.7,2.3,2.0,1.7,1.0,0 };
double calc(double score){
	if (score >= 95)
		return 4.3;
	else if (score >= 90)
		return 4.0;
	else if (score >= 85)
		return 3.7;
	else if (score >= 80)
		return 3.3;
	else if (score >= 75)
		return 3.0;
	else if (score >= 70)
		return 2.7;
	else if (score >= 67)
		return 2.3;
	else if (score >= 65)
		return 2.0;
	else if (score >= 62)
		return 1.7;
	else if (score >= 60)
		return 1.0;
	else
		return 0.0;
}
void dfs(int cur, int sum, double score){
	if (sum < 0)
		return;
	if (cur == 3){
		Max = max(Max, calc(sum) + score);
		return;
	}
	for (int j = 0; j < 11; j++)
		dfs(cur + 1, sum - scores[j], score + gpa[j]);
}
int main()
{
	int test, n;
	cin >> test;
	for (int i = 0; i < test; ++i) {
		cin >> n;
		Max = 0;
		dfs(0, n, 0);
		//cout << Max << endl;
		printf("%.1lf\n", Max);
	}
}

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int gcd(int a, int b) {
	if (b == 0)
		return a;
	return gcd(b, a % b);
}

int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int test, a, b;
	cin >> test;
	vector<vector<int>> v(1001, vector<int>(1001, 0));
	for (int i = 1; i <= 1000; ++i) {
		for (int j = 1; j <= 1000; ++j) {
			if (gcd(i, j) == 1) {
				v[i][j] = max(v[i][j - 1], v[i - 1][j]) + 1;
			}
			else {
				v[i][j] = max(v[i][j - 1], v[i - 1][j]);
			}
		}
	}
	for (int i = 0; i < test; ++i) {
		cin >> a >> b;
		if (a < b)
			cout << v[a][b] << endl;
		else
			cout << v[b][a] << endl;
	}
	return 0;
}

// 已存在分支，使用强推
git remote add origin <仓库地址>
git push origin master:master -f

// 已存在分支，不能强推
git remote add origin <仓库地址>
git branch --set-upstream-to=origin/master master
//rebase 先把远端的代码拉到本地，插入本地代码提交log的最底下，即变基
git rebase
git push

// 远程分支不存在
git remote add origin <仓库地址>
// 本地master分支push到远端master分支
git push origin master:master

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include<iostream>
#include<pthread.h>
#include<assert.h>
#include<vector>
#include<queue>

#include "lock.h"

using namespace std;

template<class T>
class threadPool{
private:
    int threadNum;
    int maxRequestNum;
    pthread_t* threads = nullptr;
    queue<T*> workQueue;
    locker poolLocker;
    sem queueState; // whether has tasks to do ? P/V operation

    static void *worker(void *arg);// pull task from workQueue
    void run();
public:
    threadPool(int thread_number = 8, int max_request = 10000);
    ~threadPool();
    bool append(T *request, int state);
    bool append_p(T *request);
};

template<class T>
threadPool<T>::threadPool(int _threadNum, int _maxRequestNum){
    if(_threadNum == 0 || _maxRequestNum == 0)
        assert(0);
    threadNum = _threadNum;
    maxRequestNum = _maxRequestNum;
    
    threads = new pthread_t[_threadNum];
    assert(threads != nullptr);

    for(int i = 0; i < _threadNum; ++i){
        int ret = pthread_create(threads + i, NULL, worker, this); // public static void worker(){...}
        if(ret != 0){
            delete[] threads;
            throw std::exception();
        }
        ret = pthread_detach(threads[i]);
        if(ret != 0){
            delete[] threads;
            throw std::exception();
        }
    }
    //std::cout << "init finished" << endl;
}

template<class T>
threadPool<T>::~threadPool(){
    delete[] threads;
}

template<class T>
bool threadPool<T>::append(T *request, int state){
    poolLocker.lock();
    if(workQueue.size() >= threadNum){
        poolLocker.unlock();
        return false;
    }
    workQueue.push(request);
    queueState.post(); // V: +1
    poolLocker.unlock();

    return true;
}

template<class T>
void* threadPool<T>::worker(void *arg){
    threadPool* pool = (threadPool*) arg; // this
    pool->run();
    return pool;
}

template<class T>
void threadPool<T>::run(){
    while(true){
        /*
        * P operation. if > 0, reduce 1 and return; else block until it > 0
        * if there are no task to do, all threads will block here.
        * else some threads will reduce and continue to run the following code.
        */
        queueState.wait(); 

        poolLocker.lock();
        if(workQueue.empty()){ // there are no task in the workQueue, loop until workQueue is not empty
            poolLocker.unlock();
            continue;
        }
        T* request = workQueue.front();
        workQueue.pop();
        poolLocker.unlock();
        if (!request){
            std::cout << "request is null" << std::endl;
            continue;
        }
        
        request->work(); // request is workinng ! 
    }
}
#endif

#ifndef LOCK_H
#define LOCK_H

#include <exception>
#include <pthread.h>
#include <semaphore.h>

class sem{
public:
    sem(){
        if (sem_init(&m_sem, 0, 0) != 0){
            throw std::exception();
        }
    }
    sem(int num){
        if (sem_init(&m_sem, 0, num) != 0){
            throw std::exception();
        }
    }
    ~sem(){
        sem_destroy(&m_sem);
    }
    bool wait(){
        return sem_wait(&m_sem) == 0;
    }
    bool post(){
        return sem_post(&m_sem) == 0;
    }
private:
    sem_t m_sem;
};
class locker{
public:
    locker(){
        if (pthread_mutex_init(&m_mutex, NULL) != 0){
            throw std::exception();
        }
    }
    ~locker(){
        pthread_mutex_destroy(&m_mutex);
    }
    bool lock(){
        return pthread_mutex_lock(&m_mutex) == 0;
    }
    bool unlock(){
        return pthread_mutex_unlock(&m_mutex) == 0;
    }
    pthread_mutex_t *get(){
        return &m_mutex;
    }
private:
    pthread_mutex_t m_mutex;
};
class cond{
public:
    cond(){
        if (pthread_cond_init(&m_cond, NULL) != 0){
            //pthread_mutex_destroy(&m_mutex);
            throw std::exception();
        }
    }
    ~cond(){
        pthread_cond_destroy(&m_cond);
    }
    bool wait(pthread_mutex_t *m_mutex){
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        ret = pthread_cond_wait(&m_cond, m_mutex);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    bool timewait(pthread_mutex_t *m_mutex, struct timespec t){
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    bool signal(){
        return pthread_cond_signal(&m_cond) == 0;
    }
    bool broadcast(){
        return pthread_cond_broadcast(&m_cond) == 0;
    }

private:
    //static pthread_mutex_t m_mutex;
    pthread_cond_t m_cond;
};
#endif

#ifndef WORKER_H_
#define WORKER_H_

#include<iostream>

class worker{
public:
    worker(int i):id(i){}
    void work(){
        std::cout << "worker: " << id << std::endl;
    }
    int getId(){return id;}
private:
    int id;
};

#endif

#include<iostream>
#include<vector>

#include "threadPool.h"
#include "worker.h"
#include <unistd.h>

using namespace std;

int main(){
    threadPool<worker>* pool = new threadPool<worker>(8, 10000);
    vector<worker*> workers;
    for(int i = 0; i < 20; ++i){
        workers.push_back(new worker(i));
    }

    for(worker* w: workers){
        while(!pool->append(w, 0)){
            
        }
    }
    pause();
    return 0;
}

// header.h
#pragma
#include<iostream>
using namespace std;
class listNode{
public:
    int val;
    listNode* next;
    listNode(int v):val(v), next(nullptr){}
};
void func1();// only declared
void func2();// only declared

// func1.cpp
#include<iostream>
#include "header.h"
using namespace std;

void func1(){
    cout << "func1" << endl;
}

//fun2.cpp
...

// main.cpp
#include "header.h"
#include<iostream>
using  namespace std;
int main(){
    func1();
    func2();
    system("pause");
    return 0;
}