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