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