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