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