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