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