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