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