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