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