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