MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                     | manufacturer    |   price |
|:--------------------------|:----------------|--------:|
| avid liquid vs 7 software | avid technology |  888.75 |

Entity B:
| title    | manufacturer   |   price |
|:---------|:---------------|--------:|
| software |                |  112.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 829
rtable_id: 1072
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium | adobe          |    1699 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe cs3 master collection academic |                |  939.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 557
rtable_id: 338
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| microsoft windows vista business full version [ dvd ] | microsoft      |  299.95 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| microsoft windows vista business 32-bit oem |                |  149.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 584
rtable_id: 1643
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                 | manufacturer   |   price |
|:------------------------------------------------------|:---------------|--------:|
| quickbooks point-of-sale pro with hardware bundle 6.0 | intuit         | 1749.95 |

Entity B:
| title                      | manufacturer   |   price |
|:---------------------------|:---------------|--------:|
| quickbooks pro 2007 3 user | intuit         |  398.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 873
rtable_id: 3063
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| quickbooks premier edition 2007 5 user multi-pack | intuit         | 1499.95 |

Entity B:
| title                                                                                            | manufacturer   |   price |
|:-------------------------------------------------------------------------------------------------|:---------------|--------:|
| intuit quickbooks premier professional services edition 2007 software win tax & finance software |                |  349.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 580
rtable_id: 2530
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| axis & allies collector 's edition | encore         |   19.99 |

Entity B:
| title                              | manufacturer   |   price |
|:-----------------------------------|:---------------|--------:|
| aspyr the sims complete collection |                |   47.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 784
rtable_id: 412
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| family tree maker version 16 deluxe | encore         |   69.95 |

Entity B:
| title                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| encore inc family tree maker 2008 platinum |                |   85.07 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 309
rtable_id: 403
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                   | manufacturer   |   price |
|:----------------------------------------|:---------------|--------:|
| adobe acrobat capture 100 000 page pack | adobe          | 1514.99 |

Entity B:
| title                                                                     | manufacturer   |   price |
|:--------------------------------------------------------------------------|:---------------|--------:|
| 22002170 adobe acrobat standard v. 8.0 complete package 1 user cd win can |                |  295.25 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 549
rtable_id: 1738
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| microsoft mappoint 2006 with gps | microsoft      |     349 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft ( r ) money 2007 deluxe |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 574
rtable_id: 3215
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| adobe after effects 7.0 professional ( mac ) | adobe          |     999 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe illustrator cs3 ( mac ) |                |     599 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 333
rtable_id: 2860
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                | manufacturer         |   price |
|:-----------------------------------------------------|:---------------------|--------:|
| instant immersion italian deluxe v2 .0 ( large box ) | topics entertainment |   29.99 |

Entity B:
| title                                                    | manufacturer   |   price |
|:---------------------------------------------------------|:---------------|--------:|
| instant immersion japanese ( audio book ) ( audio book ) |                |   19.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1353
rtable_id: 1475
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe illustrator cs3 upgrade from freehand [ mac ] | adobe          |     199 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe cs3 flash professional upgrade |                |  205.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 216
rtable_id: 192
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                     | manufacturer         |   price |
|:------------------------------------------|:---------------------|--------:|
| phonics success deluxe 2006 ( large box ) | topics entertainment |   49.99 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| high school success deluxe 2006 |                |     7.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 453
rtable_id: 2045
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title              | manufacturer       |   price |
|:-------------------|:-------------------|--------:|
| funny faces deluxe | fogware publishing |   19.99 |

Entity B:
| title                          | manufacturer   |   price |
|:-------------------------------|:---------------|--------:|
| fogware publishing funny faces |                |   16.93 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1331
rtable_id: 638
label: 1
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft powerpoint 2004 ( mac ) | microsoft      |  229.99 |

Entity B:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| microsoft office visio standard 2007 ( pc ) |                |  249.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 225
rtable_id: 2847
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                     | manufacturer   |   price |
|:------------------------------------------|:---------------|--------:|
| quickbooks premier nonprofit edition 2007 | intuit         |  399.95 |

Entity B:
| title                     | manufacturer   |   price |
|:--------------------------|:---------------|--------:|
| quickbooks ( r ) pro 2007 |                |  179.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 520
rtable_id: 3092
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                            | manufacturer         | price   |
|:---------------------------------|:---------------------|:--------|
| instant immersion hawaiian audio | topics entertainment |         |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| instant immers italian dlux 2 . |                |   36.11 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1341
rtable_id: 3016
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                                    | manufacturer       |   price |
|:-------------------------------------------------------------------------|:-------------------|--------:|
| microsoft crm professional cal 3.0 product upgrade license pack user cal | microsoft software |    9980 |

Entity B:
| title                                              | manufacturer   |   price |
|:---------------------------------------------------|:---------------|--------:|
| microsoft office and windows training professional |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 135
rtable_id: 1497
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                       | manufacturer   |   price |
|:--------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium | adobe          |    1699 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| adobe cs3 design premium academic |                |  575.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 557
rtable_id: 939
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                   | manufacturer    |   price |
|:----------------------------------------|:----------------|--------:|
| mavis beacon teaches typing 17 standard | encore software |   19.99 |

Entity B:
| title                                 | manufacturer   |   price |
|:--------------------------------------|:---------------|--------:|
| mavis beacon teaches typing 16 deluxe |                |    34.9 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 903
rtable_id: 2027
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                                 | manufacturer       |   price |
|:----------------------------------------------------------------------|:-------------------|--------:|
| microsoft visual studio professional w/msdn professional 2005 renewal | microsoft software |     799 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| microsoft academic microsoft office project 2003 professional |                |  176.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1305
rtable_id: 1007
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                      | manufacturer     |   price |
|:---------------------------|:-----------------|--------:|
| punch ! 5 in 1 home design | punch ! software |   39.99 |

Entity B:
| title                                                                   | manufacturer   |   price |
|:------------------------------------------------------------------------|:---------------|--------:|
| punch software 14100 punch ! professional home design suite for windows | punch software |   62.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1287
rtable_id: 1026
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                      | manufacturer   |   price |
|:-------------------------------------------|:---------------|--------:|
| tlc dr. seuss reading learning system 2008 | encore         |   19.99 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| encore software 13871 tlc reader rabbit 1st grade learning system 2008 |                |   17.97 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 124
rtable_id: 2089
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft visio standard 2007 | microsoft      |  259.95 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| microsoft ( r ) office standard 2007 |                |  399.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 522
rtable_id: 1010
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| microsoft windows vista ultimate upgrade [ dvd ] | microsoft      |  259.95 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| microsoft word 2004 upgrade for mac os x apple & mac software |                |  108.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 514
rtable_id: 2600
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| adobe photoshop cs3 upgrade [ mac ] | adobe          |     199 |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| adobe photoshop elements 4.0 mac |                |   79.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 543
rtable_id: 145
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| family tree maker 2008 platinum | encore         |   99.95 |

Entity B:
| title                                        | manufacturer   |   price |
|:---------------------------------------------|:---------------|--------:|
| encore inc family tree maker v 16 essentials |                |   25.75 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 711
rtable_id: 279
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                               | manufacturer     |   price |
|:----------------------------------------------------|:-----------------|--------:|
| crystal reports 11 professional full product french | business objects |  909.66 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| upg crystal reports 11 pro french |                |  264.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 207
rtable_id: 2287
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium upgrade | adobe          |     799 |

Entity B:
| title                                                                           | manufacturer   |   price |
|:--------------------------------------------------------------------------------|:---------------|--------:|
| cakewalk sonar 5 producer edition competative upgrade music production software |                |     299 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 736
rtable_id: 2212
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                                              | manufacturer   |   price |
|:-----------------------------------------------------------------------------------|:---------------|--------:|
| m-audio pro tools m-powered 7.3 m-audio compatible world-class production software | m-audio        |  299.99 |

Entity B:
| title                                                                  | manufacturer   |   price |
|:-----------------------------------------------------------------------|:---------------|--------:|
| digidesign pro tools hd 7.3 software upgrade music production software |                |     199 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 827
rtable_id: 2321
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                            | manufacturer   | price   |
|:-------------------------------------------------|:---------------|:--------|
| pcanywhere 11.0 host only cd-rom xp 98 nt w2k me | symantec       |         |

Entity B:
| title                            | manufacturer   |   price |
|:---------------------------------|:---------------|--------:|
| symantec pcanywhere 11.0 windows |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 486
rtable_id: 2446
label: 1
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                  | manufacturer    | price   |
|:---------------------------------------|:----------------|:--------|
| the print shop 21 deluxe by broderbund | encore software |         |

Entity B:
| title                   | manufacturer   |   price |
|:------------------------|:---------------|--------:|
| the print shop ( r ) 22 |                |   29.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 946
rtable_id: 1157
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                               | manufacturer   |   price |
|:----------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 production premium upgrade | adobe          |     799 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| adobe dreamweaver cs3 upgrade |                |  205.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 736
rtable_id: 954
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                        | manufacturer   |   price |
|:-----------------------------|:---------------|--------:|
| quicken 2007 home & business | intuit         |   89.95 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| quicken 2007 premier win cd | intuit         |   73.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 577
rtable_id: 3055
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                  | manufacturer     |   price |
|:---------------------------------------|:-----------------|--------:|
| spy sweeper w/antivirus family edition | webroot software |   49.95 |

Entity B:
| title                                                         | manufacturer   |   price |
|:--------------------------------------------------------------|:---------------|--------:|
| 50411 spy sweeper with antivirus complete package 3 users win |                |   38.91 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 999
rtable_id: 1870
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                             | manufacturer   |   price |
|:--------------------------------------------------|:---------------|--------:|
| microsoft office small business 2007 full version | microsoft      |  449.95 |

Entity B:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| office mac 2004 microsoft 731-01002 |                |  331.77 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 604
rtable_id: 2411
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title               | manufacturer     |   price |
|:--------------------|:-----------------|--------:|
| photo explosion 3.0 | nova development |   29.99 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| photo explosion deluxe 3.0 nova |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1362
rtable_id: 2840
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                           | manufacturer            |   price |
|:--------------------------------|:------------------------|--------:|
| sibelius 4 professional edition | sibelius-software-ltd . |  599.99 |

Entity B:
| title                                | manufacturer   |   price |
|:-------------------------------------|:---------------|--------:|
| adobe flash cs3 professional ( mac ) |                |     699 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1148
rtable_id: 2839
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                    | manufacturer    |   price |
|:-------------------------|:----------------|--------:|
| marine aquarium + sharks | encore software |    9.95 |

Entity B:
| title                                                      | manufacturer   |   price |
|:-----------------------------------------------------------|:---------------|--------:|
| marine aquarium & goldfish screen saver by encore software |                |   19.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 882
rtable_id: 2139
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                            | manufacturer   |   price |
|:-------------------------------------------------|:---------------|--------:|
| adobe creative suite cs3 design standard upgrade | adobe          |     399 |

Entity B:
| title                           | manufacturer   |   price |
|:--------------------------------|:---------------|--------:|
| adobe cs3 web standard academic |                |  389.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 615
rtable_id: 977
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                               | manufacturer   |   price |
|:------------------------------------|:---------------|--------:|
| microsoft word 2004 upgrade ( mac ) | microsoft      |  109.99 |

Entity B:
| title                         | manufacturer   |   price |
|:------------------------------|:---------------|--------:|
| microsoft office outlook 2007 |                |  109.95 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 823
rtable_id: 2877
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| adobe premiere elements 3.0 | adobe          |  161.73 |

Entity B:
| title                       | manufacturer   |   price |
|:----------------------------|:---------------|--------:|
| documents to go premium 7.0 |                |   49.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 484
rtable_id: 3224
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                                          | manufacturer       |   price |
|:---------------------------------------------------------------|:-------------------|--------:|
| microsoft visual studio test agent 2005 cd 1 processor license | microsoft software |    5099 |

Entity B:
| title                                                                                    | manufacturer   |   price |
|:-----------------------------------------------------------------------------------------|:---------------|--------:|
| 122-00411 microsoft visual studio 2005 team edition for software testers complete packag |                | 2184.73 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 393
rtable_id: 1852
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                                            | manufacturer         |   price |
|:-------------------------------------------------|:---------------------|--------:|
| microsoft office & windows training professional | topics entertainment |   49.95 |

Entity B:
| title                             | manufacturer   |   price |
|:----------------------------------|:---------------|--------:|
| microsoft office 2004 std upgrade |                |  219.99 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 753
rtable_id: 915
label: 0
Task: Entity-Matching (source dataset: Amazon-Google)

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:
| title                           | manufacturer        |   price |
|:--------------------------------|:--------------------|--------:|
| photoshop elements 4 edu mac 1u | adobe-education-box |      69 |

Entity B:
| title                                                                                   | manufacturer   |   price |
|:----------------------------------------------------------------------------------------|:---------------|--------:|
| 29180162 adobe photoshop elements 4.0 plus adobe premiere elements 2.0 complete package |                |  138.28 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1235
rtable_id: 1900
label: 0