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