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