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