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