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