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