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