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