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