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