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