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