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