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