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