MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                       | city          | phone         | type        |   class |
|:-----------------|:---------------------------|:--------------|:--------------|:------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7547 | continental |      70 |

Entity B:
| name                                     | addr                        | city          | phone        | type        |   class |
|:-----------------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` morton \ 's of chicago ( las vegas ) ' | ' 3200 las vegas blvd. s. ' | ` las vegas ' | 702-893-0703 | steakhouses |     667 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 70
rtable_id: 133
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name               | addr                     | city          | phone         | type   |   class |
|:-------------------|:-------------------------|:--------------|:--------------|:-------|--------:|
| ` mandarin court ' | ' 1510 e. flamingo rd. ' | ` las vegas ' | 702/737 -1234 | asian  |     443 |

Entity B:
| name                      | addr                     | city          | phone        | type    |   class |
|:--------------------------|:-------------------------|:--------------|:-------------|:--------|--------:|
| ` buzio \ 's in the rio ' | ' 3700 w. flamingo rd. ' | ` las vegas ' | 702-252-7697 | seafood |     658 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 443
rtable_id: 124
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                  | city            | phone         | type        |   class |
|:-------|:----------------------|:----------------|:--------------|:------------|--------:|
| patina | ' 5955 melrose ave. ' | ` los angeles ' | 213/467 -1108 | californian |      16 |

Entity B:
| name   | addr                  | city            | phone        | type        |   class |
|:-------|:----------------------|:----------------|:-------------|:------------|--------:|
| citrus | ' 6703 melrose ave. ' | ` los angeles ' | 213-857-0034 | californian |       6 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 16
rtable_id: 224
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name      | addr                | city         | phone         | type     |   class |
|:----------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` jo jo ' | ' 160 e. 64th st. ' | ` new york ' | 212/223 -5656 | american |      38 |

Entity B:
| name      | addr                | city              | phone        | type              |   class |
|:----------|:--------------------|:------------------|:-------------|:------------------|--------:|
| ` jo jo ' | ' 160 e. 64th st. ' | ` new york city ' | 212-223-5656 | ` french bistro ' |      38 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 38
rtable_id: 256
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                | city         | phone         | type     |   class |
|:-------|:--------------------|:-------------|:--------------|:---------|--------:|
| march  | ' 405 e. 58th st. ' | ` new york ' | 212/754 -6272 | american |      46 |

Entity B:
| name   | addr                | city              | phone        | type   |   class |
|:-------|:--------------------|:------------------|:-------------|:-------|--------:|
| dawat  | ' 210 e. 58th st. ' | ` new york city ' | 212-355-7555 | indian |      32 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 46
rtable_id: 250
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                       | city          | phone         | type        |   class |
|:-------|:---------------------------|:--------------|:--------------|:------------|--------:|
| bistro | ' 3400 las vegas blvd. s ' | ` las vegas ' | 702/791 -7111 | continental |     429 |

Entity B:
| name                  | addr                        | city          | phone        | type   |   class |
|:----------------------|:----------------------------|:--------------|:-------------|:-------|--------:|
| ` madame ching \ 's ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7111 | asian  |     662 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 429
rtable_id: 128
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                | city         | phone         | type     |   class |
|:-----------------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` pen & pencil ' | ' 205 e. 45th st. ' | ` new york ' | 212/682 -8660 | american |     325 |

Entity B:
| name                | addr                | city              | phone        | type    |   class |
|:--------------------|:--------------------|:------------------|:-------------|:--------|--------:|
| ` shun lee palace ' | ' 155 e. 55th st. ' | ` new york city ' | 212-371-8844 | chinese |      60 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 326
rtable_id: 278
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name        | addr                   | city    | phone         | type        |   class |
|:------------|:-----------------------|:--------|:--------------|:------------|--------:|
| ` luna si ' | ' 1931 peachtree rd. ' | atlanta | 404/355 -5993 | continental |     405 |

Entity B:
| name                                      | addr                      | city    | phone        | type                 |   class |
|:------------------------------------------|:--------------------------|:--------|:-------------|:---------------------|--------:|
| ` ritz-carlton dining room ( buckhead ) ' | ' 3434 peachtree rd. ne ' | atlanta | 404-237-2700 | ` american ( new ) ' |      90 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 308
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                           | addr                   | city            | phone         | type    |   class |
|:-------------------------------|:-----------------------|:----------------|:--------------|:--------|--------:|
| ` il fornaio cucina italiana ' | ' 301 n. beverly dr. ' | ` los angeles ' | 310/550 -8330 | italian |     139 |

Entity B:
| name                                            | addr                   | city              | phone        | type        |   class |
|:------------------------------------------------|:-----------------------|:------------------|:-------------|:------------|--------:|
| ` ruth \ 's chris steak house ( los angeles ) ' | ' 224 s. beverly dr. ' | ` beverly hills ' | 310-859-8744 | steakhouses |     593 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 142
rtable_id: 59
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name        | addr                   | city    | phone         | type        |   class |
|:------------|:-----------------------|:--------|:--------------|:------------|--------:|
| ` luna si ' | ' 1931 peachtree rd. ' | atlanta | 404/355 -5993 | continental |     405 |

Entity B:
| name   | addr                   | city    | phone        | type         |   class |
|:-------|:-----------------------|:--------|:-------------|:-------------|--------:|
| nava   | ' 3060 peachtree rd. ' | atlanta | 404-240-1984 | southwestern |     706 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 405
rtable_id: 172
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                       | city          | phone         | type                  |   class |
|:------------------|:---------------------------|:--------------|:--------------|:----------------------|--------:|
| ` the bacchanal ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7525 | ` only in las vegas ' |     449 |

Entity B:
| name                           | addr                        | city          | phone        | type        |   class |
|:-------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` michael \ 's ( las vegas ) ' | ' 3595 las vegas blvd. s. ' | ` las vegas ' | 702-737-7111 | continental |     664 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 449
rtable_id: 130
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                       | city          | phone         | type   |   class |
|:-------|:---------------------------|:--------------|:--------------|:-------|--------:|
| mikado | ' 3400 las vegas blvd. s ' | ` las vegas ' | 702/791 -7111 | asian  |     446 |

Entity B:
| name             | addr                        | city          | phone        | type               |   class |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 446
rtable_id: 288
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name      | addr              | city              | phone         | type     |   class |
|:----------|:------------------|:------------------|:--------------|:---------|--------:|
| boulevard | ' 1 mission st. ' | ` san francisco ' | 415/543 -6084 | american |      96 |

Entity B:
| name      | addr              | city              | phone        | type                 |   class |
|:----------|:------------------|:------------------|:-------------|:---------------------|--------:|
| boulevard | ' 1 mission st. ' | ` san francisco ' | 415-543-6084 | ` american ( new ) ' |      96 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 96
rtable_id: 314
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                    | city            | phone         | type    |   class |
|:----------------|:------------------------|:----------------|:--------------|:--------|--------:|
| ` ca \ ` brea ' | ' 346 s. la brea ave. ' | ` los angeles ' | 213/938 -2863 | italian |     118 |

Entity B:
| name      | addr                    | city            | phone        | type        |   class |
|:----------|:------------------------|:----------------|:-------------|:------------|--------:|
| campanile | ' 624 s. la brea ave. ' | ` los angeles ' | 213-938-1447 | californian |       4 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 121
rtable_id: 222
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                 | addr                       | city          | phone         | type                    |   class |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` ralph \ 's diner ' | ' 3000 las vegas blvd. s ' | ` las vegas ' | 702/732 -6330 | ` coffee shops/diners ' |     448 |

Entity B:
| name             | addr                        | city          | phone        | type               |   class |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 448
rtable_id: 288
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type             |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-----------------|--------:|
| ` steak house ' | ' 2880 las vegas blvd. s ' | ` las vegas ' | 702/734 -0410 | ` steak houses ' |      72 |

Entity B:
| name             | addr                        | city          | phone        | type               |   class |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 72
rtable_id: 288
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                         | addr           | city          | phone         | type     |   class |
|:-----------------------------|:---------------|:--------------|:--------------|:---------|--------:|
| ` center stage plaza hotel ' | ' 1 main st. ' | ` las vegas ' | 702/386 -2512 | american |     436 |

Entity B:
| name      | addr              | city              | phone        | type                 |   class |
|:----------|:------------------|:------------------|:-------------|:---------------------|--------:|
| boulevard | ' 1 mission st. ' | ` san francisco ' | 415-543-6084 | ` american ( new ) ' |      96 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 436
rtable_id: 314
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                       | city          | phone         | type   |   class |
|:--------------|:---------------------------|:--------------|:--------------|:-------|--------:|
| ` chin \ 's ' | ' 3200 las vegas blvd. s ' | ` las vegas ' | 702/733 -8899 | asian  |      67 |

Entity B:
| name             | addr                        | city          | phone        | type               |   class |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 67
rtable_id: 288
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                | city         | phone         | type     |   class |
|:-----------------|:--------------------|:-------------|:--------------|:---------|--------:|
| ` pen & pencil ' | ' 205 e. 45th st. ' | ` new york ' | 212/682 -8660 | american |     325 |

Entity B:
| name                   | addr                | city              | phone        | type        |   class |
|:-----------------------|:--------------------|:------------------|:-------------|:------------|--------:|
| ` sparks steak house ' | ' 210 e. 46th st. ' | ` new york city ' | 212-687-4855 | steakhouses |     641 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 326
rtable_id: 107
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                         | addr                      | city    | phone         | type      |   class |
|:-----------------------------|:--------------------------|:--------|:--------------|:----------|--------:|
| ` mambo restaurante cubano ' | ' 1402 n. highland ave. ' | atlanta | 404/874 -2626 | caribbean |     406 |

Entity B:
| name                              | addr                   | city                | phone        | type   |   class |
|:----------------------------------|:-----------------------|:--------------------|:-------------|:-------|--------:|
| ` uncle bill \ 's pancake house ' | ' 1305 highland ave. ' | ` manhattan beach ' | 310-545-5177 | diners |     599 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 406
rtable_id: 65
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                | city         | phone         | type   |   class |
|:-------|:--------------------|:-------------|:--------------|:-------|--------:|
| dawat  | ' 210 e. 58th st. ' | ` new york ' | 212/355 -7555 | asian  |      32 |

Entity B:
| name                             | addr              | city              | phone        | type   |   class |
|:---------------------------------|:------------------|:------------------|:-------------|:-------|--------:|
| ` lespinasse ( new york city ) ' | ' 2 e. 55th st. ' | ` new york city ' | 212-339-6719 | asian  |      43 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 32
rtable_id: 261
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr              | city         | phone         | type    |   class |
|:-------|:------------------|:-------------|:--------------|:--------|--------:|
| oceana | '55 e. 54th st. ' | ` new york ' | 212/759 -5941 | seafood |      50 |

Entity B:
| name    | addr              | city              | phone        | type         |   class |
|:--------|:------------------|:------------------|:-------------|:-------------|--------:|
| aquavit | '13 w. 54th st. ' | ` new york city ' | 212-307-7311 | scandinavian |      24 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 50
rtable_id: 242
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name         | addr                        | city            | phone         | type     |   class |
|:-------------|:----------------------------|:----------------|:--------------|:---------|--------:|
| ` the palm ' | ' 9001 santa monica blvd. ' | ` los angeles ' | 310/550 -8811 | american |      15 |

Entity B:
| name              | addr                               | city              | phone        | type                 |   class |
|:------------------|:-----------------------------------|:------------------|:-------------|:---------------------|--------:|
| ` belvedere the ' | ' 9882 little santa monica blvd. ' | ` beverly hills ' | 310-788-2306 | ` pacific new wave ' |     537 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 15
rtable_id: 3
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name       | addr                   | city    | phone         | type   |   class |
|:-----------|:-----------------------|:--------|:--------------|:-------|--------:|
| ciboulette | ' 1529 piedmont ave. ' | atlanta | 404/874 -7600 | french |      79 |

Entity B:
| name                      | addr                   | city    | phone        | type               |   class |
|:--------------------------|:-----------------------|:--------|:-------------|:-------------------|--------:|
| ` ciboulette restaurant ' | ' 1529 piedmont ave. ' | atlanta | 404-874-7600 | ` french ( new ) ' |      79 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 79
rtable_id: 297
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                  | city              | phone         | type    |   class |
|:-----------------|:----------------------|:------------------|:--------------|:--------|--------:|
| ` rose pistola ' | ' 532 columbus ave. ' | ` san francisco ' | 415/399 -0499 | italian |     111 |

Entity B:
| name            | addr                  | city              | phone        | type    |   class |
|:----------------|:----------------------|:------------------|:-------------|:--------|--------:|
| ` campo santo ' | ' 240 columbus ave. ' | ` san francisco ' | 415-433-9623 | mexican |     724 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 111
rtable_id: 189
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type         |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-------------|--------:|
| ` coyote cafe ' | ' 3799 las vegas blvd. s ' | ` las vegas ' | 702/891 -7349 | southwestern |      68 |

Entity B:
| name             | addr                        | city          | phone        | type               |   class |
|:-----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` palace court ' | ' 3570 las vegas blvd. s. ' | ` las vegas ' | 702-731-7110 | ` french ( new ) ' |      70 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 68
rtable_id: 288
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                       | city          | phone         | type        |   class |
|:-------|:---------------------------|:--------------|:--------------|:------------|--------:|
| bistro | ' 3400 las vegas blvd. s ' | ` las vegas ' | 702/791 -7111 | continental |     429 |

Entity B:
| name          | addr                        | city          | phone        | type    |   class |
|:--------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` chin \ 's ' | ' 3200 las vegas blvd. s. ' | ` las vegas ' | 702-733-8899 | chinese |      67 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 429
rtable_id: 285
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                               | addr                       | city          | phone         | type    |   class |
|:-----------------------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` margarita \ 's mexican cantina ' | ' 3120 las vegas blvd. s ' | ` las vegas ' | 702/794 -8200 | mexican |     444 |

Entity B:
| name            | addr                        | city          | phone        | type               |   class |
|:----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` monte carlo ' | ' 3145 las vegas blvd. s. ' | ` las vegas ' | 702-733-4524 | ` french ( new ) ' |     665 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 444
rtable_id: 131
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name             | addr                | city         | phone         | type   |   class |
|:-----------------|:--------------------|:-------------|:--------------|:-------|--------:|
| ` le bernardin ' | ' 155 w. 51st st. ' | ` new york ' | 212/489 -1515 | french |      41 |

Entity B:
| name               | addr                | city              | phone        | type                   |   class |
|:-------------------|:--------------------|:------------------|:-------------|:-----------------------|--------:|
| ` les celebrites ' | ' 155 w. 58th st. ' | ` new york city ' | 212-484-5113 | ` french ( classic ) ' |      42 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 41
rtable_id: 260
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                         | addr                        | city    | phone         | type        |   class |
|:-----------------------------|:----------------------------|:--------|:--------------|:------------|--------:|
| ` beesley \ 's of buckhead ' | ' 260 e. paces ferry road ' | atlanta | 404/264 -1334 | continental |     384 |

Entity B:
| name                          | addr                          | city    | phone        | type        |   class |
|:------------------------------|:------------------------------|:--------|:-------------|:------------|--------:|
| ` hedgerose heights inn the ' | ' 490 e. paces ferry rd. ne ' | atlanta | 404-233-7673 | continental |      82 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 384
rtable_id: 300
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                   | city            | phone         | type   |   class |
|:----------------|:-----------------------|:----------------|:--------------|:-------|--------:|
| ` le colonial ' | ' 8783 beverly blvd. ' | ` los angeles ' | 310/289 -0660 | asian  |     144 |

Entity B:
| name                           | addr                   | city   | phone        | type             |   class |
|:-------------------------------|:-----------------------|:-------|:-------------|:-----------------|--------:|
| ` jan \ 's family restaurant ' | ' 8424 beverly blvd. ' | la     | 213-651-2866 | ` coffee shops ' |     557 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 147
rtable_id: 23
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                  | city            | phone         | type        |   class |
|:-------|:----------------------|:----------------|:--------------|:------------|--------:|
| patina | ' 5955 melrose ave. ' | ` los angeles ' | 213/467 -1108 | californian |      16 |

Entity B:
| name                | addr                  | city   | phone        | type     |   class |
|:--------------------|:----------------------|:-------|:-------------|:---------|--------:|
| ` sweet lady jane ' | ' 8360 melrose ave. ' | la     | 213-653-7145 | desserts |     596 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 16
rtable_id: 62
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                   | city    | phone         | type        |   class |
|:-------|:-----------------------|:--------|:--------------|:------------|--------:|
| tomtom | ' 3393 peachtree rd. ' | atlanta | 404/264 -1163 | continental |     422 |

Entity B:
| name                  | addr                   | city    | phone        | type              |   class |
|:----------------------|:-----------------------|:--------|:-------------|:------------------|--------:|
| ` brasserie le coze ' | ' 3393 peachtree rd. ' | atlanta | 404-266-1440 | ` french bistro ' |      77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 422
rtable_id: 295
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                | city         | phone         | type    |   class |
|:-------|:--------------------|:-------------|:--------------|:--------|--------:|
| bruno  | ' 240 e. 58th st. ' | ` new york ' | 212/688 -4190 | italian |     195 |

Entity B:
| name       | addr                | city              | phone        | type    |   class |
|:-----------|:--------------------|:------------------|:-------------|:--------|--------:|
| petrossian | ' 182 w. 58th st. ' | ` new york city ' | 212-245-2214 | russian |      52 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 197
rtable_id: 270
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                       | city          | phone         | type    |   class |
|:------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` circus circus ' | ' 2880 las vegas blvd. s ' | ` las vegas ' | 702/734 -0410 | buffets |     437 |

Entity B:
| name                    | addr                        | city          | phone        | type        |   class |
|:------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` spago ( las vegas ) ' | ' 3500 las vegas blvd. s. ' | ` las vegas ' | 702-369-6300 | californian |     670 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 437
rtable_id: 136
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                                       | city         | phone         | type              |   class |
|:----------------|:-------------------------------------------|:-------------|:--------------|:------------------|--------:|
| ` teresa \ 's ' | ' 103 1st ave. between 6th and 7th sts . ' | ` new york ' | 212/228 -0604 | ` east european ' |     358 |

Entity B:
| name          | addr             | city              | phone        | type               |   class |
|:--------------|:-----------------|:------------------|:-------------|:-------------------|--------:|
| ` masa \ 's ' | ' 648 bush st. ' | ` san francisco ' | 415-989-7154 | ` french ( new ) ' |     106 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 358
rtable_id: 324
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                | city         | phone         | type   |   class |
|:-------|:--------------------|:-------------|:--------------|:-------|--------:|
| dawat  | ' 210 e. 58th st. ' | ` new york ' | 212/355 -7555 | asian  |      32 |

Entity B:
| name    | addr                | city              | phone        | type    |   class |
|:--------|:--------------------|:------------------|:-------------|:--------|--------:|
| felidia | ' 243 e. 58th st. ' | ` new york city ' | 212-758-1479 | italian |      33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 32
rtable_id: 251
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                                  | addr                   | city    | phone         | type          |   class |
|:--------------------------------------|:-----------------------|:--------|:--------------|:--------------|--------:|
| ` dining room ritz-carlton buckhead ' | ' 3434 peachtree rd. ' | atlanta | 404/237 -2700 | international |      90 |

Entity B:
| name                  | addr                   | city    | phone        | type              |   class |
|:----------------------|:-----------------------|:--------|:-------------|:------------------|--------:|
| ` brasserie le coze ' | ' 3393 peachtree rd. ' | atlanta | 404-266-1440 | ` french bistro ' |      77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 90
rtable_id: 295
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                  | city            | phone         | type        |   class |
|:-------|:----------------------|:----------------|:--------------|:------------|--------:|
| citrus | ' 6703 melrose ave. ' | ` los angeles ' | 213/857 -0034 | californian |       6 |

Entity B:
| name                              | addr                  | city            | phone        | type              |   class |
|:----------------------------------|:----------------------|:----------------|:-------------|:------------------|--------:|
| ` le chardonnay ( los angeles ) ' | ' 8284 melrose ave. ' | ` los angeles ' | 213-655-8880 | ` french bistro ' |      12 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 6
rtable_id: 230
label: 0