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