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