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