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