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